source: spip-zone/_plugins_/taxonomie/trunk/inc/taxonomie.php @ 114150

Last change on this file since 114150 was 114150, checked in by eric@…, 7 months ago

Renommer la fonction regne_lister() en regne_lister_defaut() et créer la fonction regne_repertorier() qui retourne les règnes chargés en base.
Ne pas afficher d'espèce si le règne n'est pas chargé.
Corriger les affichages si la liste des taxons est vide.

  • Property svn:eol-style set to native
File size: 20.7 KB
Line 
1<?php
2/**
3 * Ce fichier contient les constantes et les fonctions de l'API du plugin Taxonomie non utilisées dans les squelettes.
4 *
5 */
6if (!defined('_ECRIRE_INC_VERSION')) {
7        return;
8}
9
10
11$GLOBALS['_taxonomie']['regnes'] = array('animalia', 'plantae', 'fungi');
12
13if (!defined('_TAXONOMIE_TYPE_RANG_PRINCIPAL')) {
14        /**
15         * Type de rang selon la nomenclature taxonomique.
16         */
17        define('_TAXONOMIE_TYPE_RANG_PRINCIPAL', 'principal');
18}
19if (!defined('_TAXONOMIE_TYPE_RANG_SECONDAIRE')) {
20        /**
21         * Type de rang selon la nomenclature taxonomique.
22         */
23        define('_TAXONOMIE_TYPE_RANG_SECONDAIRE', 'secondaire');
24}
25if (!defined('_TAXONOMIE_TYPE_RANG_INTERCALAIRE')) {
26        /**
27         * Type de rang selon la nomenclature taxonomique.
28         */
29        define('_TAXONOMIE_TYPE_RANG_INTERCALAIRE', 'intercalaire');
30}
31
32// TODO : vérifier les rangs stirp, morph, aberration, unspecified.
33// TODO : vérifier pourquoi le rang serie n'est pas dans la liste de ITIS
34$GLOBALS['_taxonomie']['rangs'] = array(
35        'kingdom'       => array('type' => _TAXONOMIE_TYPE_RANG_PRINCIPAL, 'est_espece' => false, 'synonyme' => ''),
36        'subkingdom'    => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
37        'infrakingdom'  => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
38        'superphylum'   => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => false, 'synonyme' => 'superdivision'),
39        'phylum'        => array('type' => _TAXONOMIE_TYPE_RANG_PRINCIPAL, 'est_espece' => false, 'synonyme' => 'division'),
40        'subphylum'     => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => false, 'synonyme' => 'subdivision'),
41        'infraphylum'   => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => false, 'synonyme' => 'infradivision'),
42        'superdivision' => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => false, 'synonyme' => 'superphylum'),
43        'division'      => array('type' => _TAXONOMIE_TYPE_RANG_PRINCIPAL, 'est_espece' => false, 'synonyme' => 'phylum'),
44        'subdivision'   => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => false, 'synonyme' => 'subphylum'),
45        'infradivision' => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => false, 'synonyme' => 'infraphylum'),
46        'superclass'    => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
47        'class'         => array('type' => _TAXONOMIE_TYPE_RANG_PRINCIPAL, 'est_espece' => false, 'synonyme' => ''),
48        'subclass'      => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
49        'infraclass'    => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
50        'superorder'    => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
51        'order'         => array('type' => _TAXONOMIE_TYPE_RANG_PRINCIPAL, 'est_espece' => false, 'synonyme' => ''),
52        'suborder'      => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
53        'infraorder'    => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
54        'section'       => array('type' => _TAXONOMIE_TYPE_RANG_SECONDAIRE, 'est_espece' => false, 'synonyme' => ''),
55        'subsection'    => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
56        'superfamily'   => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
57        'family'        => array('type' => _TAXONOMIE_TYPE_RANG_PRINCIPAL, 'est_espece' => false, 'synonyme' => ''),
58        'subfamily'     => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
59        'tribe'         => array('type' => _TAXONOMIE_TYPE_RANG_SECONDAIRE, 'est_espece' => false, 'synonyme' => ''),
60        'subtribe'      => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
61        'genus'         => array('type' => _TAXONOMIE_TYPE_RANG_PRINCIPAL, 'est_espece' => false, 'synonyme' => ''),
62        'subgenus'      => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
63        'species'       => array('type' => _TAXONOMIE_TYPE_RANG_PRINCIPAL, 'est_espece' => true, 'synonyme' => ''),
64        'subspecies'    => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => true, 'synonyme' => ''),
65        'variety'       => array('type' => _TAXONOMIE_TYPE_RANG_SECONDAIRE, 'est_espece' => true, 'synonyme' => ''),
66        'subvariety'    => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => true, 'synonyme' => ''),
67        'form'          => array('type' => _TAXONOMIE_TYPE_RANG_SECONDAIRE, 'est_espece' => true, 'synonyme' => ''),
68        'subform'       => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => true, 'synonyme' => ''),
69        'race'          => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => true, 'synonyme' => 'variety'),
70        'stirp'         => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => true, 'synonyme' => ''),
71        'morph'         => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => true, 'synonyme' => ''),
72        'aberration'    => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => true, 'synonyme' => ''),
73        'unspecified'   => array('type' => _TAXONOMIE_TYPE_RANG_INTERCALAIRE, 'est_espece' => true, 'synonyme' => '')
74);
75
76if (!defined('_TAXONOMIE_RANG_REGNE')) {
77        /**
78         * Nom anglais du rang principal `règne`.
79         */
80        define('_TAXONOMIE_RANG_REGNE', 'kingdom');
81}
82if (!defined('_TAXONOMIE_RANG_GENRE')) {
83        /**
84         * Nom anglais du rang principal `genre`.
85         */
86        define('_TAXONOMIE_RANG_GENRE', 'genus');
87}
88if (!defined('_TAXONOMIE_RANG_ESPECE')) {
89        /**
90         * Nom anglais du rang principal `espèce`.
91         */
92        define('_TAXONOMIE_RANG_ESPECE', 'species');
93}
94
95if (!defined('_TAXONOMIE_LANGUES_POSSIBLES')) {
96        /**
97         * Liste des langues utilisables pour les noms communs et les textes des taxons.
98         */
99        define('_TAXONOMIE_LANGUES_POSSIBLES', 'fr:en:es:pt:de:it');
100}
101
102
103// -----------------------------------------------------------------------
104// ---------------------- API GESTION DES REGNES -------------------------
105// -----------------------------------------------------------------------
106
107/**
108 * Charge tous les taxons d'un règne donné fourni dans le fichier ITIS, du règne lui-même jusqu'aux taxons de genre.
109 * Les nom communs anglais, français, espagnols, etc, peuvent aussi être chargés en complément mais
110 * ne couvrent pas l'ensemble des taxons.
111 * Le modifications effectuées manuellement sur ces taxons sont conservées.
112 *
113 * @package SPIP\TAXONOMIE\REGNE
114 *
115 * @api
116 *
117 * @uses regne_existe()
118 * @uses taxon_preserver()
119 * @uses regne_vider()
120 * @uses itis_read_hierarchy()
121 * @uses itis_find_language()
122 * @uses itis_read_vernaculars()
123 *
124 * @param string $regne
125 *        Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
126 * @param array  $codes_langue
127 *        Tableau des codes des langues (au sens SPIP) à charger pour les noms communs des taxons.
128 *
129 * @return bool
130 *        `true` si le chargement a réussi, `false` sinon
131 */
132function regne_charger($regne, $codes_langue = array()) {
133
134        $retour = false;
135        $taxons_preserves = array();
136
137        // Vérifie si le règne existe bien dans la table spip_taxons
138        $regne_existe = regne_existe($regne, $meta_regne);
139        if ($regne_existe) {
140                // Sauvegarde des taxons ayant été modifiés manuellement suite à leur création automatique.
141                $taxons_preserves = taxon_preserver($regne);
142
143                // Vider le règne avant de le recharger
144                regne_vider($regne);
145        }
146
147        // Lire le fichier json fournissant la hiérarchie des rangs du règne en cours de chargement.
148        $meta_regne = array();
149        include_spip('services/itis/itis_api');
150        $meta_regne['rangs']['hierarchie'] = itis_read_ranks($regne, $meta_regne['rangs']['sha']);
151
152        // Lecture de la hiérarchie des taxons à partir du fichier texte extrait de la base ITIS
153        $taxons = itis_read_hierarchy($regne, $meta_regne['rangs']['hierarchie'], $meta_regne['sha']);
154
155        // Ajout des noms communs extraits de la base ITIS dans la langue demandée
156        if ($taxons) {
157                $meta_regne['compteur'] = count($taxons);
158                $traductions = array();
159                foreach ($codes_langue as $_code_langue) {
160                        $langue = itis_find_language($_code_langue);
161                        if ($langue) {
162                                $noms = itis_read_vernaculars($langue, $sha_langue);
163                                if ($noms) {
164                                        $meta_regne['traductions']['itis'][$_code_langue]['sha'] = $sha_langue;
165                                        $nb_traductions_langue = 0;
166                                        foreach ($noms as $_tsn => $_nom) {
167                                                if (array_key_exists($_tsn, $taxons)) {
168                                                        // On ajoute les traductions qui sont de la forme [xx]texte
169                                                        // On sauvegarde le tsn concerné afin de clore les traductions
170                                                        // avec les balises multi et d'optimiser ainsi les traitements
171                                                        // sachant qu'il y a très peu de traductions comparées aux taxons
172                                                        $taxons[$_tsn]['nom_commun'] .= $_nom;
173                                                        $nb_traductions_langue += 1;
174                                                        $traductions[$_tsn] = $_tsn;
175                                                }
176                                        }
177                                        $meta_regne['traductions']['itis'][$_code_langue]['compteur'] = $nb_traductions_langue;
178                                }
179                        }
180                }
181
182                // Clore les traductions avec les balises multi
183                if ($traductions) {
184                        foreach ($traductions as $_tsn) {
185                                $taxons[$_tsn]['nom_commun'] = '<multi>' . $taxons[$_tsn]['nom_commun'] . '</multi>';
186                        }
187                }
188
189                // Ré-injection des modifications manuelles effectuées sur les taxons importés via le fichier ITIS du règne.
190                // -- descriptif, texte, sources: remplacement
191                // -- nom commun: merge en considérant que la mise à jour manuelle est prioritaire
192                // -- edite: positionné à 1, on conserve bien sur l'indicateur d'édition
193                if (!empty($taxons_preserves['edites'])) {
194                        foreach ($taxons_preserves['edites'] as $_taxon_edite) {
195                                if (($tsn = $_taxon_edite['tsn']) and (array_key_exists($tsn, $taxons))) {
196                                        $taxons[$tsn]['descriptif'] = $_taxon_edite['descriptif'];
197                                        $taxons[$tsn]['texte'] = $_taxon_edite['texte'];
198                                        $taxons[$tsn]['sources'] = $_taxon_edite['sources'];
199                                        $taxons[$tsn]['nom_commun'] = taxon_merger_traductions(
200                                                $_taxon_edite['nom_commun'],
201                                                $taxons[$tsn]['nom_commun']);
202                                        $taxons[$tsn]['edite'] = 'oui';
203                                }
204                        }
205                }
206
207                // On formate le taxon pour l'insertion en BD.
208                $taxons = array_values($taxons);
209                spip_log("Insertion règne `${regne}` - nombre de taxons : " . count($taxons), 'taxonomie');
210
211                // Insertion dans la base de données
212                $retour = sql_insertq_multi('spip_taxons', $taxons);
213                if ($retour) {
214                        // Insérer les informations de chargement dans une meta propre au règne.
215                        // Ca permettra de tester l'utilité ou pas d'un rechargement du règne
216                        $meta_regne['maj'] = date('Y-m-d H:i:s');
217                        $meta_regne['fichier'] = "${regne}_genus.txt";
218
219                        // Mise à jour de la meta du règne.
220                        include_spip('inc/config');
221                        ecrire_config("taxonomie_$regne", $meta_regne);
222                }
223        }
224
225        return $retour;
226}
227
228
229/**
230 * Supprime de la base de données tous les taxons importés à partir du rapport hiérarchique d'un règne donné.
231 * La meta concernant les informations de chargement du règne est aussi effacée.
232 * Les modifications manuelles effectuées sur ces taxons sont effacées : elles doivent donc être préservées au préalable.
233 *
234 * @package SPIP\TAXONOMIE\REGNE
235 *
236 * @api
237 *
238 * @param string $regne
239 *        Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
240 *
241 * @return bool
242 *        `true` si le vidage a réussi, `false` sinon
243 */
244function regne_vider($regne) {
245
246        $where = array('regne=' . sql_quote($regne), 'importe=' . sql_quote('oui'));
247        $retour = sql_delete('spip_taxons', $where);
248        if ($retour !== false) {
249                // Supprimer la meta propre au règne.
250                effacer_meta("taxonomie_$regne");
251                $retour = true;
252        }
253
254        return $retour;
255}
256
257
258/**
259 * Retourne l'existence ou pas d'un règne en base de données.
260 * La fonction scrute les taxons importés de la table `spip_taxons` et non la meta propre au règne.
261 *
262 * @package SPIP\TAXONOMIE\REGNE
263 *
264 * @api
265 *
266 * @param string $regne
267 *        Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
268 * @param array  $meta_regne
269 *        Meta propre au règne, créée lors du chargement de celui-ci et retournée si le règne
270 *        existe.
271 *
272 * @return bool
273 *        `true` si le règne existe, `false` sinon.
274 */
275function regne_existe($regne, &$meta_regne) {
276
277        $meta_regne = array();
278        $existe = false;
279
280        $where = array('regne=' . sql_quote($regne), 'importe=' . sql_quote('oui'));
281        $retour = sql_countsel('spip_taxons', $where);
282        if ($retour) {
283                // Récupérer la meta propre au règne afin de la retourner.
284                include_spip('inc/config');
285                $meta_regne = lire_config("taxonomie_$regne");
286                $existe = true;
287        }
288
289        return $existe;
290}
291
292/**
293 * Renvoie la liste des règnes supportés par le plugin.
294 *
295 * @package SPIP\TAXONOMIE\REGNE
296 *
297 * @api
298 *
299 * @return array
300 *        Liste des noms scientifiques en minuscules des règnes supportés.
301 */
302function regne_lister_defaut() {
303
304        return $GLOBALS['_taxonomie']['regnes'];
305}
306
307
308/**
309 * Renvoie le type de rang principal, secondaire ou intercalaire.
310 *
311 * @package SPIP\TAXONOMIE\RANG
312 *
313 * @api
314 *
315 * @param string $rang
316 *        Nom anglais du rang en minuscules.
317 *
318 * @return string
319 *        `principal`, `secondaire` ou `intercalaire` si le rang est valide, chaine vide sinon.
320 */
321function rang_informer_type($rang) {
322
323        // Initialisation à chaine vide pour le cas où le rang n'est pas dans la liste des rangs admis.
324        $type = '';
325
326        if (!empty($GLOBALS['_taxonomie']['rangs'][$rang])) {
327                $type = $GLOBALS['_taxonomie']['rangs'][$rang]['type'];
328        }
329
330        return $type;
331}
332
333
334/**
335 * Détermine si un rang est celui d'une espèce ou d'un taxon de rang inférieur.
336 *
337 * @package SPIP\TAXONOMIE\RANG
338 *
339 * @api
340 *
341 * @param string $rang
342 *        Nom anglais du rang en minuscules.
343 *
344 * @return bool
345 *        `true` si le rang est celui d'une espèce ou d'un taxon de rang inférieur, `false` sinon.
346 */
347function rang_est_espece($rang) {
348
349        // Initialisation à false pour le cas où le rang n'est pas dans la liste des rangs admis.
350        $est_espece = false;
351
352        if (!empty($GLOBALS['_taxonomie']['rangs'][$rang])) {
353                $est_espece = $GLOBALS['_taxonomie']['rangs'][$rang]['est_espece'];
354        }
355
356        return $est_espece;
357}
358
359
360// -----------------------------------------------------------------------
361// ---------------------- API GESTION DES TAXONS -------------------------
362// -----------------------------------------------------------------------
363
364/**
365 * Extrait, de la table `spip_taxons`, la liste des taxons non espèce d'un règne donné - importés via un fichier ITIS -
366 * ayant fait l'objet d'une modification manuelle et la liste des taxons non espèce créés lors de l'ajout d'une espèce
367 * et donc non importés avec le fichier ITIS.
368 *
369 * @package SPIP\TAXONOMIE\TAXON
370 *
371 * @api
372 *
373 * @param string $regne
374 *        Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
375 *
376 * @return array
377 *        Liste des taxons modifiées manuellement et créés suite à l'ajout d'une espèce.
378 *        Chaque élément de la liste est un tableau composé, pour les taxons modifiés manuellement des index
379 *        `tsn`, `nom_commun`, `descriptif` et pour les taxons créés via une espèce de tous les champs de l'objet
380 *        taxon, à l'exception de l'id (`id_taxon`) et de la date de mise à jour (`maj`).
381 */
382function taxon_preserver($regne) {
383
384        // Récupération de la description de la table spip_taxons afin de connaitre la liste des colonnes.
385        include_spip('base/objets');
386        $description_table = lister_tables_objets_sql('spip_taxons');
387
388        // Récupération de la liste des taxons importés via le fichier ITIS du règne concerné et édités manuellement.
389        // Ces champs éditables (nom_commun, descriptif, texte et sources) seront réinjectés après le chargement du règne
390        // via un update.
391        $from = array('spip_taxons');
392        $select = array_merge($description_table['champs_editables'], array('tsn'));
393        $where = array(
394                'regne=' . sql_quote($regne),
395                'edite=' . sql_quote('oui'),
396                'importe=' . sql_quote('oui'),
397                'espece=' . sql_quote('non')
398        );
399        $taxons['edites'] = sql_allfetsel($select, $from, $where);
400
401        // Récupération de la liste des taxons non importés via le fichier ITIS du règne concerné mais créés lors de l'ajout
402        // d'une espèce.
403        // Ces taxons préservés uniquement pour le besoin de l'exportation par IEConfig car il ne sont pas effacés
404        // lors du rechargement du règne.
405        // -- on récupère tous les champs du taxons sauf ceux qui seront mis à jour automatique lors de l'insertion de
406        //    l'objet en BD (id_taxon, maj).
407        $select = array_diff(array_keys($description_table['field']), array('id_taxon', 'maj'));
408        $where = array(
409                'regne=' . sql_quote($regne),
410                'importe=' . sql_quote('non'),
411                'espece=' . sql_quote('non')
412        );
413        $taxons['crees'] = sql_allfetsel($select, $from, $where);
414
415        return $taxons;
416}
417
418
419/**
420 * Fusionne les traductions d'une balise `<multi>` avec celles d'une autre balise `<multi>`.
421 * L'une des balise est considérée comme prioritaire ce qui permet de régler le cas où la même
422 * langue est présente dans les deux balises.
423 * Si on ne trouve pas de balise `<multi>` dans l'un ou l'autre des paramètres, on considère que
424 * le texte est tout même formaté de la façon suivante : texte0[langue1]texte1[langue2]texte2...
425 *
426 * @package SPIP\TAXONOMIE\TAXON
427 *
428 * @api
429 *
430 * @param string $multi_prioritaire
431 *        Balise multi considérée comme prioritaire en cas de conflit sur une langue.
432 * @param string $multi_non_prioritaire
433 *        Balise multi considérée comme non prioritaire en cas de conflit sur une langue.
434 *
435 * @return string
436 *        La chaine construite est toujours une balise `<multi>` complète ou une chaine vide sinon.
437 */
438function taxon_merger_traductions($multi_prioritaire, $multi_non_prioritaire) {
439
440        $multi_merge = '';
441
442        // On extrait le contenu de la balise <multi> si elle existe.
443        $multi_prioritaire = trim($multi_prioritaire);
444        $multi_non_prioritaire = trim($multi_non_prioritaire);
445
446        // Si les deux balises sont identiques on sort directement avec le multi prioritaire ce qui améliore les
447        // performances.
448        if ($multi_prioritaire == $multi_non_prioritaire) {
449                $multi_merge = $multi_prioritaire;
450        } else {
451                include_spip('inc/filtres');
452                if (preg_match(_EXTRAIRE_MULTI, $multi_prioritaire, $match)) {
453                        $multi_prioritaire = trim($match[1]);
454                }
455                if (preg_match(_EXTRAIRE_MULTI, $multi_non_prioritaire, $match)) {
456                        $multi_non_prioritaire = trim($match[1]);
457                }
458
459                if ($multi_prioritaire) {
460                        if ($multi_non_prioritaire) {
461                                // On extrait les traductions sous forme de tableau langue=>traduction.
462                                $traductions_prioritaires = extraire_trads($multi_prioritaire);
463                                $traductions_non_prioritaires = extraire_trads($multi_non_prioritaire);
464
465                                // On complète les traductions prioritaires avec les traductions non prioritaires dont la langue n'est pas
466                                // présente dans les traductions prioritaires.
467                                foreach ($traductions_non_prioritaires as $_lang => $_traduction) {
468                                        if (!array_key_exists($_lang, $traductions_prioritaires)) {
469                                                $traductions_prioritaires[$_lang] = $_traduction;
470                                        }
471                                }
472
473                                // On construit le contenu de la balise <multi> mergé à partir des traductions prioritaires mises à jour.
474                                // Les traductions vides sont ignorées.
475                                ksort($traductions_prioritaires);
476                                foreach ($traductions_prioritaires as $_lang => $_traduction) {
477                                        if ($_traduction) {
478                                                $multi_merge .= ($_lang ? '[' . $_lang . ']' : '') . trim($_traduction);
479                                        }
480                                }
481                        } else {
482                                $multi_merge = $multi_prioritaire;
483                        }
484                } else {
485                        $multi_merge = $multi_non_prioritaire;
486                }
487
488                // Si le contenu est non vide on l'insère dans une balise <multi>
489                if ($multi_merge) {
490                        $multi_merge = '<multi>' . $multi_merge . '</multi>';
491                }
492        }
493
494        return $multi_merge;
495}
496
497
498/**
499 * Traduit un champ de la table `spip_taxons` dans la langue du site.
500 *
501 * @package SPIP\TAXONOMIE\TAXON
502 *
503 * @api
504 *
505 * @param string $champ
506 *        Nom du champ dans la base de données.
507 *
508 * @return string
509 *        Traduction du champ dans la langue du site.
510 */
511function taxon_traduire_champ($champ) {
512
513        $traduction = '';
514        if ($champ) {
515                $traduction = _T("taxon:champ_${champ}_label");
516        }
517
518        return $traduction;
519}
520
521
522/**
523 * Renvoie la liste des services de taxonomie utilisés par le plugin en tenant compte de la configuration
524 * choisi par le webmestre.
525 *
526 * @package SPIP\TAXONOMIE\TAXON
527 *
528 * @api
529 *
530 * @return array
531 *        Tableau des services utilisés sous la forme [alias] = titre du service.
532 */
533function taxon_lister_services() {
534
535        // On initialise la liste avec le service ITOS qui est toujours utilisé.
536        $services = array('itis');
537
538        // On lit la configuration pour voir quels autres services sont autorisés à l'utilisation
539        include_spip('inc/config');
540        $services = array_flip(array_merge($services, lire_config('taxonomie/services_utilises')));
541
542        // On met à jour la liste avec le titre de chaque service
543        foreach ($services as $_service => $_index) {
544                $services[$_service] = _T("taxonomie:label_service_${_service}");
545        }
546
547        return $services;
548}
Note: See TracBrowser for help on using the repository browser.