Changeset 113820 in spip-zone


Ignore:
Timestamp:
Feb 8, 2019, 5:21:43 PM (9 days ago)
Author:
eric@…
Message:

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

Location:
_plugins_/taxonomie/trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/taxonomie/trunk/formulaires/charger_regne.php

    r109602 r113820  
    2626 */
    2727function formulaires_charger_regne_charger() {
     28
     29        // Initialisation du tableau des variables fournies au formulaire.
    2830        $valeurs = array();
    29         include_spip('inc/taxonomie');
    3031
    3132        // Lister les actions sur les règnes
     
    3738        // Acquérir la liste des règnes gérer par le plugin et leur statut de chargement
    3839        // Désactiver l'action vider si aucun règne n'est chargé
     40        include_spip('inc/taxonomie');
    3941        $aucun_regne_charge = true;
    4042        $regnes = regne_lister();
     
    5254
    5355        // Acquérir la liste des langues utilisables par le plugin et stockées dans la configuration.
     56        include_spip('inc/lang');
    5457        $langues_utilisees = lire_config('taxonomie/langues_utilisees');
    5558        foreach ($langues_utilisees as $_code_langue) {
     
    7073 */
    7174function formulaires_charger_regne_verifier() {
     75
     76        // Initialisation des messages d'erreur
    7277        $erreurs = array();
    7378
     
    9499 */
    95100function formulaires_charger_regne_traiter() {
     101
     102        // Initialisation du retour de traitement du formulaire (message, editable).
    96103        $retour = array();
    97104
     105        // Lecture de l'action et règne concerné
    98106        $action = _request('action_regne');
    99107        $regne = _request('regne');
     108
     109        // Vérifier que le règne existe (cad a déjà été chargé).
     110        include_spip('inc/taxonomie');
    100111        $regne_existe = regne_existe($regne, $meta_regne);
    101112
  • _plugins_/taxonomie/trunk/formulaires/creer_espece.php

    r113806 r113820  
    6868        // car il ne sera alors pas possible de créer correctement l'espèce avec sa hiérarchie de taxons.
    6969        include_spip('inc/taxonomie');
    70         include_spip('taxonomie_fonctions');
    7170        $regnes = regne_lister();
    7271        foreach ($regnes as $_regne) {
     
    151150
    152151                                // Appel de l'API de recherche d'ITIS en fonction du type et de la correspondance de recherche
    153                                 include_spip('services/itis/itis_api');
    154152                                $action = $type_recherche;
    155153                                if (($type_recherche == 'commonname') and ($correspondance == 'debut')) {
     
    158156                                        $action = 'commonnameend';
    159157                                }
     158                                include_spip('services/itis/itis_api');
    160159                                $taxons = itis_search_tsn($action, $recherche, $recherche_exacte);
    161160                                if ($taxons) {
  • _plugins_/taxonomie/trunk/genie/taxonomie_actualiser_itis.php

    r109603 r113820  
    3636        $shas = itis_review_sha();
    3737
    38         include_spip('taxonomie_fonctions');
    3938        foreach ($regnes as $_regne) {
    4039                $regne_a_recharger = false;
  • _plugins_/taxonomie/trunk/inc/taxonomie.php

    r113704 r113820  
    11<?php
    22/**
    3  * Ce fichier contient l'ensemble des constantes et des utilitaires nécessaires au fonctionnement du plugin.
     3 * Ce fichier contient les constantes et les fonctions de l'API du plugin Taxonomie non utilisées dans les squelettes.
    44 *
    55 */
     
    101101
    102102
     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
    103293/**
    104294 * Renvoie la liste des règnes supportés par le plugin.
     
    168358}
    169359
     360
     361// -----------------------------------------------------------------------
     362// ---------------------- API GESTION DES TAXONS -------------------------
     363// -----------------------------------------------------------------------
    170364
    171365/**
     
    325519        return $traduction;
    326520}
     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}
  • _plugins_/taxonomie/trunk/inc/taxonomie_cacher.php

    r113721 r113820  
    188188
    189189        // On constitue la liste des services requis par l'appel
    190         include_spip('taxonomie_fonctions');
     190        include_spip('inc/taxonomie');
    191191        $services = taxon_lister_services();
    192192        if ($service) {
  • _plugins_/taxonomie/trunk/taxonomie_autorisations.php

    r109691 r113820  
    288288function autoriser_espece_creer_dist($faire, $type, $id, $qui, $opt) {
    289289
     290        // On vérifie qu'un règne est bien déjà chargé
    290291        include_spip('inc/taxonomie');
    291         include_spip('taxonomie_fonctions');
    292 
    293         // On vérifie qu'un règne est bien déjà chargé
    294292        $regnes = regne_lister();
    295293        $regne_existe = false;
  • _plugins_/taxonomie/trunk/taxonomie_fonctions.php

    r113719 r113820  
    11<?php
    22/**
    3  * Ce fichier contient l'ensemble des fonctions implémentant l'API du plugin Taxonomie accessible depuis
    4  * les squelettes.
     3 * Ce fichier contient les fonctions d'API du plugin Taxonomie utilisées comme filtre dans les squelettes.
     4 * Les autres fonctions de l'API sont dans le fichier `inc/taxonomie`.
    55 *
    66 */
    77if (!defined('_ECRIRE_INC_VERSION')) {
    88        return;
    9 }
    10 
    11 
    12 /**
    13  * 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.
    14  * Les nom communs anglais, français, espagnols, etc, peuvent aussi être chargés en complément mais
    15  * ne couvrent pas l'ensemble des taxons.
    16  * Le modifications effectuées manuellement sur ces taxons sont conservées.
    17  *
    18  * @package SPIP\TAXONOMIE\REGNE
    19  *
    20  * @api
    21  * @filtre
    22  *
    23  * @uses regne_existe()
    24  * @uses taxon_preserver()
    25  * @uses regne_vider()
    26  * @uses itis_read_hierarchy()
    27  * @uses itis_find_language()
    28  * @uses itis_read_vernaculars()
    29  *
    30  * @param string $regne
    31  *        Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
    32  * @param array  $codes_langue
    33  *        Tableau des codes des langues (au sens SPIP) à charger pour les noms communs des taxons.
    34  *
    35  * @return bool
    36  *        `true` si le chargement a réussi, `false` sinon
    37  */
    38 function regne_charger($regne, $codes_langue = array()) {
    39 
    40         $retour = false;
    41         $taxons_preserves = array();
    42 
    43         // Vérifie si le règne existe bien dans la table spip_taxons
    44         $regne_existe = regne_existe($regne, $meta_regne);
    45         include_spip('inc/taxonomie');
    46         if ($regne_existe) {
    47                 // Sauvegarde des taxons ayant été modifiés manuellement suite à leur création automatique.
    48                 $taxons_preserves = taxon_preserver($regne);
    49 
    50                 // Vider le règne avant de le recharger
    51                 regne_vider($regne);
    52         }
    53 
    54         // Lire le fichier json fournissant la hiérarchie des rangs du règne en cours de chargement.
    55         $meta_regne = array();
    56         include_spip('services/itis/itis_api');
    57         $meta_regne['rangs']['hierarchie'] = itis_read_ranks($regne, $meta_regne['rangs']['sha']);
    58 
    59         // Lecture de la hiérarchie des taxons à partir du fichier texte extrait de la base ITIS
    60         $taxons = itis_read_hierarchy($regne, $meta_regne['rangs']['hierarchie'], $meta_regne['sha']);
    61 
    62         // Ajout des noms communs extraits de la base ITIS dans la langue demandée
    63         if ($taxons) {
    64                 $meta_regne['compteur'] = count($taxons);
    65                 $traductions = array();
    66                 foreach ($codes_langue as $_code_langue) {
    67                         $langue = itis_find_language($_code_langue);
    68                         if ($langue) {
    69                                 $noms = itis_read_vernaculars($langue, $sha_langue);
    70                                 if ($noms) {
    71                                         $meta_regne['traductions']['itis'][$_code_langue]['sha'] = $sha_langue;
    72                                         $nb_traductions_langue = 0;
    73                                         foreach ($noms as $_tsn => $_nom) {
    74                                                 if (array_key_exists($_tsn, $taxons)) {
    75                                                         // On ajoute les traductions qui sont de la forme [xx]texte
    76                                                         // On sauvegarde le tsn concerné afin de clore les traductions
    77                                                         // avec les balises multi et d'optimiser ainsi les traitements
    78                                                         // sachant qu'il y a très peu de traductions comparées aux taxons
    79                                                         $taxons[$_tsn]['nom_commun'] .= $_nom;
    80                                                         $nb_traductions_langue += 1;
    81                                                         $traductions[$_tsn] = $_tsn;
    82                                                 }
    83                                         }
    84                                         $meta_regne['traductions']['itis'][$_code_langue]['compteur'] = $nb_traductions_langue;
    85                                 }
    86                         }
    87                 }
    88 
    89                 // Clore les traductions avec les balises multi
    90                 if ($traductions) {
    91                         foreach ($traductions as $_tsn) {
    92                                 $taxons[$_tsn]['nom_commun'] = '<multi>' . $taxons[$_tsn]['nom_commun'] . '</multi>';
    93                         }
    94                 }
    95 
    96                 // Ré-injection des modifications manuelles effectuées sur les taxons importés via le fichier ITIS du règne.
    97                 // -- descriptif, texte, sources: remplacement
    98                 // -- nom commun: merge en considérant que la mise à jour manuelle est prioritaire
    99                 // -- edite: positionné à 1, on conserve bien sur l'indicateur d'édition
    100                 if (!empty($taxons_preserves['edites'])) {
    101                         foreach ($taxons_preserves['edites'] as $_taxon_edite) {
    102                                 if (($tsn = $_taxon_edite['tsn']) and (array_key_exists($tsn, $taxons))) {
    103                                         $taxons[$tsn]['descriptif'] = $_taxon_edite['descriptif'];
    104                                         $taxons[$tsn]['texte'] = $_taxon_edite['texte'];
    105                                         $taxons[$tsn]['sources'] = $_taxon_edite['sources'];
    106                                         $taxons[$tsn]['nom_commun'] = taxon_merger_traductions(
    107                                                 $_taxon_edite['nom_commun'],
    108                                                 $taxons[$tsn]['nom_commun']);
    109                                         $taxons[$tsn]['edite'] = 'oui';
    110                                 }
    111                         }
    112                 }
    113 
    114                 // On formate le taxon pour l'insertion en BD.
    115                 $taxons = array_values($taxons);
    116 
    117                 // Insertion dans la base de données
    118                 $retour = sql_insertq_multi('spip_taxons', $taxons);
    119                 if ($retour) {
    120                         // Insérer les informations de chargement dans une meta propre au règne.
    121                         // Ca permettra de tester l'utilité ou pas d'un rechargement du règne
    122                         $meta_regne['maj'] = date('Y-m-d H:i:s');
    123                         $meta_regne['fichier'] = "${regne}_genus.txt";
    124 
    125                         // Mise à jour de la meta du règne.
    126                         include_spip('inc/config');
    127                         ecrire_config("taxonomie_$regne", $meta_regne);
    128                 }
    129         }
    130 
    131         return $retour;
    132 }
    133 
    134 
    135 /**
    136  * Supprime de la base de données tous les taxons importés à partir du rapport hiérarchique d'un règne donné.
    137  * La meta concernant les informations de chargement du règne est aussi effacée.
    138  * Les modifications manuelles effectuées sur ces taxons sont effacées : elles doivent donc être préservées au préalable.
    139  *
    140  * @package SPIP\TAXONOMIE\REGNE
    141  *
    142  * @api
    143  * @filtre
    144  *
    145  * @param string $regne
    146  *        Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
    147  *
    148  * @return bool
    149  *        `true` si le vidage a réussi, `false` sinon
    150  */
    151 function regne_vider($regne) {
    152 
    153         $where = array('regne=' . sql_quote($regne), 'importe=' . sql_quote('oui'));
    154         $retour = sql_delete('spip_taxons', $where);
    155         if ($retour !== false) {
    156                 // Supprimer la meta propre au règne.
    157                 effacer_meta("taxonomie_$regne");
    158                 $retour = true;
    159         }
    160 
    161         return $retour;
    162 }
    163 
    164 
    165 /**
    166  * Retourne l'existence ou pas d'un règne en base de données.
    167  * La fonction scrute les taxons importés de la table `spip_taxons` et non la meta propre au règne.
    168  *
    169  * @package SPIP\TAXONOMIE\REGNE
    170  *
    171  * @api
    172  * @filtre
    173  *
    174  * @param string $regne
    175  *        Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
    176  * @param array  $meta_regne
    177  *        Meta propre au règne, créée lors du chargement de celui-ci et retournée si le règne
    178  *        existe.
    179  *
    180  * @return bool
    181  *        `true` si le règne existe, `false` sinon.
    182  */
    183 function regne_existe($regne, &$meta_regne) {
    184 
    185         $meta_regne = array();
    186         $existe = false;
    187 
    188         $where = array('regne=' . sql_quote($regne), 'importe=' . sql_quote('oui'));
    189         $retour = sql_countsel('spip_taxons', $where);
    190         if ($retour) {
    191                 // Récupérer la meta propre au règne afin de la retourner.
    192                 include_spip('inc/config');
    193                 $meta_regne = lire_config("taxonomie_$regne");
    194                 $existe = true;
    195         }
    196 
    197         return $existe;
    1989}
    19910
     
    329140        return $puce;
    330141}
    331 
    332 
    333 /**
    334  * Renvoie la liste des services de taxonomie utilisés par le plugin en tenant compte de la configuration
    335  * choisi par le webmestre.
    336  *
    337  * @package SPIP\TAXONOMIE\TAXON
    338  *
    339  * @api
    340  * @filtre
    341  *
    342  * @return array
    343  *        Tableau des services utilisés sous la forme [alias] = titre du service.
    344  */
    345 function taxon_lister_services() {
    346 
    347         // On initialise la liste avec le service ITOS qui est toujours utilisé.
    348         $services = array('itis');
    349 
    350         // On lit la configuration pour voir quels autres services sont autorisés à l'utilisation
    351         include_spip('inc/config');
    352         $services = array_flip(array_merge($services, lire_config('taxonomie/services_utilises')));
    353 
    354         // On met à jour la liste avec le titre de chaque service
    355         foreach ($services as $_service => $_index) {
    356                 $services[$_service] = _T("taxonomie:label_service_${_service}");
    357         }
    358 
    359         return $services;
    360 }
  • _plugins_/taxonomie/trunk/taxonomie_ieconfig.php

    r113677 r113820  
    163163        // Les metas de chargement de chaque règne ne sont pas exportées mais on identifie quand même la liste des règnes
    164164        // insérés dans la base. Les taxons seront ensuite exportés par règne pour permettre un import plus ciblé.
    165         include_spip('taxonomie_fonctions');
    166165        include_spip('inc/taxonomie');
    167166        $export['regnes'] = array();
  • _plugins_/taxonomie/trunk/taxonomie_pipelines.php

    r113715 r113820  
    9090                                                // On publie les taxons en évitant une ré-entrance (donc sans appeler l'api objet)
    9191                                                // mais en utilisant directement une mise à jour sql.
    92 //                                              include_spip('action/editer_objet');
    9392                                                foreach ($ascendance as $_parent) {
    9493                                                        if ($_parent['espece'] == 'oui') {
     
    9695                                                                        $maj = array('statut' => $statut_nouveau, 'edite' => 'oui');
    9796                                                                        sql_updateq($from, $maj, 'id_taxon=' . intval($_parent['id_taxon']));
    98 //                                                                      objet_modifier('taxon', intval($_parent['id_taxon']), array('statut' => $statut_nouveau));
    9997                                                                }
    10098                                                        } else {
Note: See TracChangeset for help on using the changeset viewer.