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

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

Transfert de certaines fonctions d'API dans inc/taxonomie car elles ne servent jamais de filtres.

  • 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_RANG_TYPE_PRINCIPAL')) {
14        /**
15         * Type de rang selon la nomenclature taxonomique.
16         */
17        define('_TAXONOMIE_RANG_TYPE_PRINCIPAL', 'principal');
18}
19if (!defined('_TAXONOMIE_RANG_TYPE_SECONDAIRE')) {
20        /**
21         * Type de rang selon la nomenclature taxonomique.
22         */
23        define('_TAXONOMIE_RANG_TYPE_SECONDAIRE', 'secondaire');
24}
25if (!defined('_TAXONOMIE_RANG_TYPE_INTERCALAIRE')) {
26        /**
27         * Type de rang selon la nomenclature taxonomique.
28         */
29        define('_TAXONOMIE_RANG_TYPE_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_RANG_TYPE_PRINCIPAL, 'est_espece' => false, 'synonyme' => ''),
36        'subkingdom'    => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
37        'infrakingdom'  => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
38        'superphylum'   => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => false, 'synonyme' => 'superdivision'),
39        'phylum'        => array('type' => _TAXONOMIE_RANG_TYPE_PRINCIPAL, 'est_espece' => false, 'synonyme' => 'division'),
40        'subphylum'     => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => false, 'synonyme' => 'subdivision'),
41        'infraphylum'   => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => false, 'synonyme' => 'infradivision'),
42        'superdivision' => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => false, 'synonyme' => 'superphylum'),
43        'division'      => array('type' => _TAXONOMIE_RANG_TYPE_PRINCIPAL, 'est_espece' => false, 'synonyme' => 'phylum'),
44        'subdivision'   => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => false, 'synonyme' => 'subphylum'),
45        'infradivision' => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => false, 'synonyme' => 'infraphylum'),
46        'superclass'    => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
47        'class'         => array('type' => _TAXONOMIE_RANG_TYPE_PRINCIPAL, 'est_espece' => false, 'synonyme' => ''),
48        'subclass'      => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
49        'infraclass'    => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
50        'superorder'    => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
51        'order'         => array('type' => _TAXONOMIE_RANG_TYPE_PRINCIPAL, 'est_espece' => false, 'synonyme' => ''),
52        'suborder'      => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
53        'infraorder'    => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
54        'section'       => array('type' => _TAXONOMIE_RANG_TYPE_SECONDAIRE, 'est_espece' => false, 'synonyme' => ''),
55        'subsection'    => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
56        'superfamily'   => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
57        'family'        => array('type' => _TAXONOMIE_RANG_TYPE_PRINCIPAL, 'est_espece' => false, 'synonyme' => ''),
58        'subfamily'     => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
59        'tribe'         => array('type' => _TAXONOMIE_RANG_TYPE_SECONDAIRE, 'est_espece' => false, 'synonyme' => ''),
60        'subtribe'      => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
61        'genus'         => array('type' => _TAXONOMIE_RANG_TYPE_PRINCIPAL, 'est_espece' => false, 'synonyme' => ''),
62        'subgenus'      => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => false, 'synonyme' => ''),
63        'species'       => array('type' => _TAXONOMIE_RANG_TYPE_PRINCIPAL, 'est_espece' => true, 'synonyme' => ''),
64        'subspecies'    => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => true, 'synonyme' => ''),
65        'variety'       => array('type' => _TAXONOMIE_RANG_TYPE_SECONDAIRE, 'est_espece' => true, 'synonyme' => ''),
66        'subvariety'    => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => true, 'synonyme' => ''),
67        'form'          => array('type' => _TAXONOMIE_RANG_TYPE_SECONDAIRE, 'est_espece' => true, 'synonyme' => ''),
68        'subform'       => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => true, 'synonyme' => ''),
69        'race'          => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => true, 'synonyme' => 'variety'),
70        'stirp'         => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => true, 'synonyme' => ''),
71        'morph'         => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => true, 'synonyme' => ''),
72        'aberration'    => array('type' => _TAXONOMIE_RANG_TYPE_INTERCALAIRE, 'est_espece' => true, 'synonyme' => ''),
73        'unspecified'   => array('type' => _TAXONOMIE_RANG_TYPE_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 * @filtre
238 *
239 * @param string $regne
240 *        Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
241 *
242 * @return bool
243 *        `true` si le vidage a réussi, `false` sinon
244 */
245function regne_vider($regne) {
246
247        $where = array('regne=' . sql_quote($regne), 'importe=' . sql_quote('oui'));
248        $retour = sql_delete('spip_taxons', $where);
249        if ($retour !== false) {
250                // Supprimer la meta propre au règne.
251                effacer_meta("taxonomie_$regne");
252                $retour = true;
253        }
254
255        return $retour;
256}
257
258
259/**
260 * Retourne l'existence ou pas d'un règne en base de données.
261 * La fonction scrute les taxons importés de la table `spip_taxons` et non la meta propre au règne.
262 *
263 * @package SPIP\TAXONOMIE\REGNE
264 *
265 * @api
266 *
267 * @param string $regne
268 *        Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
269 * @param array  $meta_regne
270 *        Meta propre au règne, créée lors du chargement de celui-ci et retournée si le règne
271 *        existe.
272 *
273 * @return bool
274 *        `true` si le règne existe, `false` sinon.
275 */
276function regne_existe($regne, &$meta_regne) {
277
278        $meta_regne = array();
279        $existe = false;
280
281        $where = array('regne=' . sql_quote($regne), 'importe=' . sql_quote('oui'));
282        $retour = sql_countsel('spip_taxons', $where);
283        if ($retour) {
284                // Récupérer la meta propre au règne afin de la retourner.
285                include_spip('inc/config');
286                $meta_regne = lire_config("taxonomie_$regne");
287                $existe = true;
288        }
289
290        return $existe;
291}
292
293/**
294 * Renvoie la liste des règnes supportés par le plugin.
295 *
296 * @package SPIP\TAXONOMIE\REGNE
297 *
298 * @api
299 *
300 * @return array
301 *        Liste des noms scientifiques en minuscules des règnes supportés.
302 */
303function regne_lister() {
304
305        return $GLOBALS['_taxonomie']['regnes'];
306}
307
308
309/**
310 * Renvoie le type de rang principal, secondaire ou intercalaire.
311 *
312 * @package SPIP\TAXONOMIE\RANG
313 *
314 * @api
315 *
316 * @param string $rang
317 *        Nom anglais du rang en minuscules.
318 *
319 * @return string
320 *        `principal`, `secondaire` ou `intercalaire` si le rang est valide, chaine vide sinon.
321 */
322function rang_informer_type($rang) {
323
324        // Initialisation à chaine vide pour le cas où le rang n'est pas dans la liste des rangs admis.
325        $type = '';
326
327        if (!empty($GLOBALS['_taxonomie']['rangs'][$rang])) {
328                $type = $GLOBALS['_taxonomie']['rangs'][$rang]['type'];
329        }
330
331        return $type;
332}
333
334
335/**
336 * Détermine si un rang est celui d'une espèce ou d'un taxon de rang inférieur.
337 *
338 * @package SPIP\TAXONOMIE\RANG
339 *
340 * @api
341 *
342 * @param string $rang
343 *        Nom anglais du rang en minuscules.
344 *
345 * @return bool
346 *        `true` si le rang est celui d'une espèce ou d'un taxon de rang inférieur, `false` sinon.
347 */
348function rang_est_espece($rang) {
349
350        // Initialisation à false pour le cas où le rang n'est pas dans la liste des rangs admis.
351        $est_espece = false;
352
353        if (!empty($GLOBALS['_taxonomie']['rangs'][$rang])) {
354                $est_espece = $GLOBALS['_taxonomie']['rangs'][$rang]['est_espece'];
355        }
356
357        return $est_espece;
358}
359
360
361// -----------------------------------------------------------------------
362// ---------------------- API GESTION DES TAXONS -------------------------
363// -----------------------------------------------------------------------
364
365/**
366 * Extrait, de la table `spip_taxons`, la liste des taxons non espèce d'un règne donné - importés via un fichier ITIS -
367 * 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
368 * et donc non importés avec le fichier ITIS.
369 *
370 * @package SPIP\TAXONOMIE\TAXON
371 *
372 * @api
373 *
374 * @param string $regne
375 *        Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
376 *
377 * @return array
378 *        Liste des taxons modifiées manuellement et créés suite à l'ajout d'une espèce.
379 *        Chaque élément de la liste est un tableau composé, pour les taxons modifiés manuellement des index
380 *        `tsn`, `nom_commun`, `descriptif` et pour les taxons créés via une espèce de tous les champs de l'objet
381 *        taxon, à l'exception de l'id (`id_taxon`) et de la date de mise à jour (`maj`).
382 */
383function taxon_preserver($regne) {
384
385        // Récupération de la description de la table spip_taxons afin de connaitre la liste des colonnes.
386        include_spip('base/objets');
387        $description_table = lister_tables_objets_sql('spip_taxons');
388
389        // Récupération de la liste des taxons importés via le fichier ITIS du règne concerné et édités manuellement.
390        // Ces champs éditables (nom_commun, descriptif, texte et sources) seront réinjectés après le chargement du règne
391        // via un update.
392        $from = array('spip_taxons');
393        $select = array_merge($description_table['champs_editables'], array('tsn'));
394        $where = array(
395                'regne=' . sql_quote($regne),
396                'edite=' . sql_quote('oui'),
397                'importe=' . sql_quote('oui'),
398                'espece=' . sql_quote('non')
399        );
400        $taxons['edites'] = sql_allfetsel($select, $from, $where);
401
402        // 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
403        // d'une espèce.
404        // Ces taxons préservés uniquement pour le besoin de l'exportation par IEConfig car il ne sont pas effacés
405        // lors du rechargement du règne.
406        // -- on récupère tous les champs du taxons sauf ceux qui seront mis à jour automatique lors de l'insertion de
407        //    l'objet en BD (id_taxon, maj).
408        $select = array_diff(array_keys($description_table['field']), array('id_taxon', 'maj'));
409        $where = array(
410                'regne=' . sql_quote($regne),
411                'importe=' . sql_quote('non'),
412                'espece=' . sql_quote('non')
413        );
414        $taxons['crees'] = sql_allfetsel($select, $from, $where);
415
416        return $taxons;
417}
418
419
420/**
421 * Fusionne les traductions d'une balise `<multi>` avec celles d'une autre balise `<multi>`.
422 * L'une des balise est considérée comme prioritaire ce qui permet de régler le cas où la même
423 * langue est présente dans les deux balises.
424 * Si on ne trouve pas de balise `<multi>` dans l'un ou l'autre des paramètres, on considère que
425 * le texte est tout même formaté de la façon suivante : texte0[langue1]texte1[langue2]texte2...
426 *
427 * @package SPIP\TAXONOMIE\TAXON
428 *
429 * @api
430 *
431 * @param string $multi_prioritaire
432 *        Balise multi considérée comme prioritaire en cas de conflit sur une langue.
433 * @param string $multi_non_prioritaire
434 *        Balise multi considérée comme non prioritaire en cas de conflit sur une langue.
435 *
436 * @return string
437 *        La chaine construite est toujours une balise `<multi>` complète ou une chaine vide sinon.
438 */
439function taxon_merger_traductions($multi_prioritaire, $multi_non_prioritaire) {
440
441        $multi_merge = '';
442
443        // On extrait le contenu de la balise <multi> si elle existe.
444        $multi_prioritaire = trim($multi_prioritaire);
445        $multi_non_prioritaire = trim($multi_non_prioritaire);
446
447        // Si les deux balises sont identiques on sort directement avec le multi prioritaire ce qui améliore les
448        // performances.
449        if ($multi_prioritaire == $multi_non_prioritaire) {
450                $multi_merge = $multi_prioritaire;
451        } else {
452                include_spip('inc/filtres');
453                if (preg_match(_EXTRAIRE_MULTI, $multi_prioritaire, $match)) {
454                        $multi_prioritaire = trim($match[1]);
455                }
456                if (preg_match(_EXTRAIRE_MULTI, $multi_non_prioritaire, $match)) {
457                        $multi_non_prioritaire = trim($match[1]);
458                }
459
460                if ($multi_prioritaire) {
461                        if ($multi_non_prioritaire) {
462                                // On extrait les traductions sous forme de tableau langue=>traduction.
463                                $traductions_prioritaires = extraire_trads($multi_prioritaire);
464                                $traductions_non_prioritaires = extraire_trads($multi_non_prioritaire);
465
466                                // On complète les traductions prioritaires avec les traductions non prioritaires dont la langue n'est pas
467                                // présente dans les traductions prioritaires.
468                                foreach ($traductions_non_prioritaires as $_lang => $_traduction) {
469                                        if (!array_key_exists($_lang, $traductions_prioritaires)) {
470                                                $traductions_prioritaires[$_lang] = $_traduction;
471                                        }
472                                }
473
474                                // On construit le contenu de la balise <multi> mergé à partir des traductions prioritaires mises à jour.
475                                // Les traductions vides sont ignorées.
476                                ksort($traductions_prioritaires);
477                                foreach ($traductions_prioritaires as $_lang => $_traduction) {
478                                        if ($_traduction) {
479                                                $multi_merge .= ($_lang ? '[' . $_lang . ']' : '') . trim($_traduction);
480                                        }
481                                }
482                        } else {
483                                $multi_merge = $multi_prioritaire;
484                        }
485                } else {
486                        $multi_merge = $multi_non_prioritaire;
487                }
488
489                // Si le contenu est non vide on l'insère dans une balise <multi>
490                if ($multi_merge) {
491                        $multi_merge = '<multi>' . $multi_merge . '</multi>';
492                }
493        }
494
495        return $multi_merge;
496}
497
498
499/**
500 * Traduit un champ de la table `spip_taxons` dans la langue du site.
501 *
502 * @package SPIP\TAXONOMIE\TAXON
503 *
504 * @api
505 *
506 * @param string $champ
507 *        Nom du champ dans la base de données.
508 *
509 * @return string
510 *        Traduction du champ dans la langue du site.
511 */
512function taxon_traduire_champ($champ) {
513
514        $traduction = '';
515        if ($champ) {
516                $traduction = _T("taxon:champ_${champ}_label");
517        }
518
519        return $traduction;
520}
521
522
523/**
524 * Renvoie la liste des services de taxonomie utilisés par le plugin en tenant compte de la configuration
525 * choisi par le webmestre.
526 *
527 * @package SPIP\TAXONOMIE\TAXON
528 *
529 * @api
530 * @filtre
531 *
532 * @return array
533 *        Tableau des services utilisés sous la forme [alias] = titre du service.
534 */
535function taxon_lister_services() {
536
537        // On initialise la liste avec le service ITOS qui est toujours utilisé.
538        $services = array('itis');
539
540        // On lit la configuration pour voir quels autres services sont autorisés à l'utilisation
541        include_spip('inc/config');
542        $services = array_flip(array_merge($services, lire_config('taxonomie/services_utilises')));
543
544        // On met à jour la liste avec le titre de chaque service
545        foreach ($services as $_service => $_index) {
546                $services[$_service] = _T("taxonomie:label_service_${_service}");
547        }
548
549        return $services;
550}
Note: See TracBrowser for help on using the repository browser.