Changeset 113806 in spip-zone


Ignore:
Timestamp:
Feb 7, 2019, 8:01:42 PM (18 months ago)
Author:
eric@…
Message:

Ajout d'une fonction de formatage pour le get hierarchyfull afin de passer le rang en minuscules.
Eviter de repasser dans la vérification de l'étape 1 car cela ne sert à rien.
Corriger l'indexation du tableau de la hiérarchie complète d'une taxon et suppression du taxon lui-même qui ne doit pas faire partie de sa propre hiérarchie.

Location:
_plugins_/taxonomie/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • _plugins_/taxonomie/trunk/formulaires/creer_espece.php

    r113790 r113806  
    112112        $erreurs = array();
    113113
    114         // Si on a déjà choisi une langue, on peut accéder à Wikipedia avec le nom scientifique et retourner
    115         // les pages trouvées (étape 2).
    116         if ($recherche = ltrim(_request('recherche'))) {
    117                 // On récupère le type de recherche et la correspondance.
    118                 $type_recherche = _request('type_recherche');
    119                 $correspondance = _request('correspondance');
    120                 $recherche_exacte = ($correspondance == 'exact');
    121                 $recherche_commence_par = ($correspondance == 'debut');
    122 
    123                 // Si la recherche est de type nom commun on ne peut rien vérifier sur le texte.
    124                 // Si la recherche est de type nom scientifique, on vérifie que le texte de recherche :
    125                 // - contient au moins deux mots
    126                 // - que le deuxième mot n'est pas un 'x' (désigne uniquement un taxon de rang supérieur hybride)
    127                 // - et que le deuxième mot n'est pas entre parenthèses (sous-genre).
    128                 $recherche_conforme = true;
    129                 if ($type_recherche == 'scientificname') {
    130                         $nombre_mots = preg_match_all('#\w+#', $recherche, $mots);
    131                         if (($nombre_mots < 2) and ($recherche_exacte)) {
    132                                 $recherche_conforme = false;
    133                         } elseif ($nombre_mots == 2) {
    134                                 if ((strtolower($mots[0][1]) == 'x')
    135                                 or ((substr($mots[0][1], 0, 1) == '(') and (substr($mots[0][1], -1) == ')'))) {
     114        // Il est inutile de vérifier à nouveau les valeurs de l'étape 1 si on est dans une étape ultérieure
     115        // car on ne modifie rien. On gagne du temps en passant outre.
     116        if (_request('_etape') == 1) {
     117                // Si on a déjà choisi une langue, on peut accéder à Wikipedia avec le nom scientifique et retourner
     118                // les pages trouvées (étape 2).
     119                if ($recherche = ltrim(_request('recherche'))) {
     120                        // On récupère le type de recherche et la correspondance.
     121                        $type_recherche = _request('type_recherche');
     122                        $correspondance = _request('correspondance');
     123                        $recherche_exacte = ($correspondance == 'exact');
     124                        $recherche_commence_par = ($correspondance == 'debut');
     125
     126                        // Si la recherche est de type nom commun on ne peut rien vérifier sur le texte.
     127                        // Si la recherche est de type nom scientifique, on vérifie que le texte de recherche :
     128                        // - contient au moins deux mots
     129                        // - que le deuxième mot n'est pas un 'x' (désigne uniquement un taxon de rang supérieur hybride)
     130                        // - et que le deuxième mot n'est pas entre parenthèses (sous-genre).
     131                        $recherche_conforme = true;
     132                        if ($type_recherche == 'scientificname') {
     133                                $nombre_mots = preg_match_all('#\w+#', $recherche, $mots);
     134                                if (($nombre_mots < 2) and ($recherche_exacte)) {
    136135                                        $recherche_conforme = false;
    137                                 }
    138                         }
    139                 }
    140 
    141                 if ($recherche_conforme) {
    142                         // On recherche le ou les taxons correspondant au texte saisi.
    143                         // -- récupération du règne
    144                         $regne =  _request('regne');
    145                         // -- suppression des espaces en trop dans la chaîne de recherche pour permettre la comparaison
    146                         //    avec le combinedName ou le commonName d'ITIS.
    147                         $recherche = preg_replace('#\s{2,}#', ' ', $recherche);
    148 
    149                         // Appel de l'API de recherche d'ITIS en fonction du type et de la correspondance de recherche
    150                         include_spip('services/itis/itis_api');
    151                         $action = $type_recherche;
    152                         if (($type_recherche == 'commonname') and ($correspondance == 'debut')) {
    153                                 $action = 'commonnamebegin';
    154                         } elseif (($type_recherche == 'commonname') and ($correspondance == 'fin')) {
    155                                 $action = 'commonnameend';
    156                         }
    157                         $taxons = itis_search_tsn($action, $recherche, $recherche_exacte);
    158                         if ($taxons) {
    159                                 if ($recherche_exacte) {
    160                                         // Si la correspondance est exacte, les informations de chaque taxon sont suffisantes pour limiter
    161                                         // d'emblée le nombre de taxon au seul qui correspond.
    162                                         $taxon_exact = array();
    163                                         foreach ($taxons as $_taxon) {
    164                                                 if ((($type_recherche == 'scientificname') and (strcasecmp($_taxon['nom_scientifique'], $recherche) === 0))
    165                                                 or (($type_recherche == 'commonname') and (strcasecmp($_taxon['nom_commun'], $recherche) === 0))) {
    166                                                         $taxon_exact = $_taxon;
    167                                                         break;
     136                                } elseif ($nombre_mots == 2) {
     137                                        if ((strtolower($mots[0][1]) == 'x')
     138                                        or ((substr($mots[0][1], 0, 1) == '(') and (substr($mots[0][1], -1) == ')'))) {
     139                                                $recherche_conforme = false;
     140                                        }
     141                                }
     142                        }
     143
     144                        if ($recherche_conforme) {
     145                                // On recherche le ou les taxons correspondant au texte saisi.
     146                                // -- récupération du règne
     147                                $regne =  _request('regne');
     148                                // -- suppression des espaces en trop dans la chaîne de recherche pour permettre la comparaison
     149                                //    avec le combinedName ou le commonName d'ITIS.
     150                                $recherche = preg_replace('#\s{2,}#', ' ', $recherche);
     151
     152                                // 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');
     154                                $action = $type_recherche;
     155                                if (($type_recherche == 'commonname') and ($correspondance == 'debut')) {
     156                                        $action = 'commonnamebegin';
     157                                } elseif (($type_recherche == 'commonname') and ($correspondance == 'fin')) {
     158                                        $action = 'commonnameend';
     159                                }
     160                                $taxons = itis_search_tsn($action, $recherche, $recherche_exacte);
     161                                if ($taxons) {
     162                                        if ($recherche_exacte) {
     163                                                // Si la correspondance est exacte, les informations de chaque taxon sont suffisantes pour limiter
     164                                                // d'emblée le nombre de taxon au seul qui correspond.
     165                                                // Néanmoins si un seul taxon est renvoyé rien est à faire car on a déjà le bon taxon.
     166                                                if (count($taxons) > 1) {
     167                                                        $taxon_exact = array();
     168                                                        foreach ($taxons as $_taxon) {
     169                                                                if ((($type_recherche == 'scientificname') and (strcasecmp($_taxon['nom_scientifique'], $recherche) === 0))
     170                                                                or (($type_recherche == 'commonname') and (strcasecmp($_taxon['nom_commun'], $recherche) === 0))) {
     171                                                                        $taxon_exact = $_taxon;
     172                                                                        break;
     173                                                                }
     174                                                        }
     175                                                        $taxons = $taxon_exact ? array($taxon_exact) : array();
     176                                                }
     177                                        } elseif ($recherche_commence_par and ($type_recherche == 'scientificname')) {
     178                                                // Si la correspondance est 'commence par' et que l'on recherche par nom scientifique, les informations
     179                                                // de chaque taxon sont suffisantes pour limiter d'emblée le nombre de taxons à ceux qui commencent
     180                                                // par la recherche.
     181                                                foreach ($taxons as $_cle => $_taxon) {
     182                                                        if (substr_compare($_taxon['nom_scientifique'], $recherche, 0, strlen($recherche), true) !== 0) {
     183                                                                unset($taxons[$_cle]);
     184                                                        }
    168185                                                }
    169186                                        }
    170                                         $taxons = $taxon_exact ? array($taxon_exact) : array();
    171                                 } elseif ($recherche_commence_par and ($type_recherche == 'scientificname')) {
    172                                         // Si la correspondance est 'commence par' et que l'on recherche par nom scientifique, les informations
    173                                         // de chaque taxon sont suffisantes pour limiter d'emblée le nombre de taxons à ceux qui commencent
    174                                         // par la recherche.
    175                                         foreach ($taxons as $_cle => $_taxon) {
    176                                                 if (substr_compare($_taxon['nom_scientifique'], $recherche, 0, strlen($recherche), true) !== 0) {
    177                                                         unset($taxons[$_cle]);
    178                                                 }
    179                                         }
    180                                 }
    181 
    182                                 // Etant donné qu'on a filtré le tableau issu de l'appel au service ITIS on vérifie à nouveau que
    183                                 // ce tableau n'est pas vide.
    184                                 if ($taxons) {
    185                                         // Si le nombre de taxons récupérés est trop important on renvoie une erreur.
    186                                         // TODO : est-on sur qu'il y a forcément un taxon ?
    187                                         if (count($taxons) <= _TAXONOMIE_RECHERCHE_MAX_ESPECES) {
    188                                                 // Construire le tableau des taxons trouvés en supprimant:
    189                                                 // - les taxons qui n'appartiennent pas au règne concerné
    190                                                 // - ou qui n'ont pas un rang compatible (uniquement pour la recherche par nom commun)
    191                                                 // - ou qui ne sont pas des appellations valides
    192                                                 // - ou qui sont déjà créés.
    193                                                 $valeurs['_taxons'] = array();
    194                                                 $valeurs['_taxon_defaut'] = 0;
    195                                                 include_spip('inc/taxonomie');
    196                                                 foreach ($taxons as $_taxon) {
    197                                                         if (!sql_countsel('spip_taxons', array('tsn=' . intval($_taxon['tsn'])))) {
    198                                                                 $taxon = itis_get_record($_taxon['tsn']);
    199                                                                 if (($taxon['usage_valide'])
    200                                                                 and (strcasecmp($taxon['regne'], $regne) === 0)
    201                                                                 and (rang_est_espece($taxon['rang_taxon']))) {
    202                                                                         if ($type_recherche == 'scientificname') {
    203                                                                                 $valeurs['_taxons'][$taxon['tsn']] = '<span class="nom_scientifique_inline">'
    204                                                                                         . $_taxon['nom_scientifique']
    205                                                                                         . '</span>'
    206                                                                                         . ' - '
    207                                                                                         . _T('taxonomie:rang_' . $taxon['rang_taxon']);
    208                                                                                 if (strcasecmp($recherche, $_taxon['nom_scientifique']) === 0) {
    209                                                                                         $valeurs['_taxon_defaut'] = $taxon['tsn'];
    210                                                                                 }
    211                                                                         } else {
    212                                                                                 // Vérifier que ce rang est compatible avec une espèce ou un rang inférieur.
    213                                                                                 $valeurs['_taxons'][$taxon['tsn']] = $_taxon['nom_commun']
    214                                                                                         . " [{$_taxon['langage']}]"
    215                                                                                         . ' - '
    216                                                                                         . _T('taxonomie:rang_' . $taxon['rang_taxon']);
    217                                                                                 if (strcasecmp($recherche, $_taxon['nom_commun']) === 0) {
    218                                                                                         $valeurs['_taxon_defaut'] = $taxon['tsn'];
     187
     188                                        // Etant donné qu'on a filtré le tableau issu de l'appel au service ITIS on vérifie à nouveau que
     189                                        // ce tableau n'est pas vide.
     190                                        if ($taxons) {
     191                                                // Si le nombre de taxons récupérés est trop important on renvoie une erreur.
     192                                                if (count($taxons) <= _TAXONOMIE_RECHERCHE_MAX_ESPECES) {
     193                                                        // Construire le tableau des taxons trouvés en supprimant:
     194                                                        // - les taxons qui n'appartiennent pas au règne concerné
     195                                                        // - ou qui n'ont pas un rang compatible (uniquement pour la recherche par nom commun)
     196                                                        // - ou qui ne sont pas des appellations valides
     197                                                        // - ou qui sont déjà créés.
     198                                                        $valeurs['_taxons'] = array();
     199                                                        $valeurs['_taxon_defaut'] = 0;
     200                                                        include_spip('inc/taxonomie');
     201                                                        foreach ($taxons as $_taxon) {
     202                                                                if (!sql_countsel('spip_taxons', array('tsn=' . intval($_taxon['tsn'])))) {
     203                                                                        $taxon = itis_get_record($_taxon['tsn']);
     204                                                                        if (($taxon['usage_valide'])
     205                                                                        and (strcasecmp($taxon['regne'], $regne) === 0)
     206                                                                        and (rang_est_espece($taxon['rang_taxon']))) {
     207                                                                                if ($type_recherche == 'scientificname') {
     208                                                                                        $valeurs['_taxons'][$taxon['tsn']] = '<span class="nom_scientifique_inline">'
     209                                                                                                . $_taxon['nom_scientifique']
     210                                                                                                . '</span>'
     211                                                                                                . ' - '
     212                                                                                                . _T('taxonomie:rang_' . $taxon['rang_taxon']);
     213                                                                                        if (strcasecmp($recherche, $_taxon['nom_scientifique']) === 0) {
     214                                                                                                $valeurs['_taxon_defaut'] = $taxon['tsn'];
     215                                                                                        }
     216                                                                                } else {
     217                                                                                        // Vérifier que ce rang est compatible avec une espèce ou un rang inférieur.
     218                                                                                        $valeurs['_taxons'][$taxon['tsn']] = $_taxon['nom_commun']
     219                                                                                                . " [{$_taxon['langage']}]"
     220                                                                                                . ' - '
     221                                                                                                . _T('taxonomie:rang_' . $taxon['rang_taxon']);
     222                                                                                        if (strcasecmp($recherche, $_taxon['nom_commun']) === 0) {
     223                                                                                                $valeurs['_taxon_defaut'] = $taxon['tsn'];
     224                                                                                        }
    219225                                                                                }
    220226                                                                        }
    221227                                                                }
    222228                                                        }
    223                                                 }
    224 
    225                                                 if ($valeurs['_taxons']) {
    226                                                         // Si aucun taxon par défaut, on prend le premier taxon de la liste.
    227                                                         if (!$valeurs['_taxon_defaut']) {
    228                                                                 reset($valeurs['_taxons']);
    229                                                                 $valeurs['_taxon_defaut'] = key($valeurs['_taxons']);
    230                                                         }
    231                                                         // On fournit ces informations au formulaire pour l'étape 2.
    232                                                         foreach ($valeurs as $_champ => $_valeur) {
    233                                                                 set_request($_champ, $_valeur);
     229
     230                                                        if ($valeurs['_taxons']) {
     231                                                                // Si aucun taxon par défaut, on prend le premier taxon de la liste.
     232                                                                if (!$valeurs['_taxon_defaut']) {
     233                                                                        reset($valeurs['_taxons']);
     234                                                                        $valeurs['_taxon_defaut'] = key($valeurs['_taxons']);
     235                                                                }
     236                                                                // On fournit ces informations au formulaire pour l'étape 2.
     237                                                                foreach ($valeurs as $_champ => $_valeur) {
     238                                                                        set_request($_champ, $_valeur);
     239                                                                }
     240                                                        } else {
     241                                                                $erreurs['message_erreur'] = _T('taxonomie:erreur_recherche_aucun_taxon');
    234242                                                        }
    235243                                                } else {
    236                                                         $erreurs['message_erreur'] = _T('taxonomie:erreur_recherche_aucun_taxon');
     244                                                        $erreurs['message_erreur'] = _T('taxonomie:erreur_recherche_max_reponses', array('nb' => count($taxons)));
    237245                                                }
    238246                                        } else {
    239                                                 $erreurs['message_erreur'] = _T('taxonomie:erreur_recherche_max_reponses', array('nb' => count($taxons)));
     247                                                $erreurs['message_erreur'] = _T('taxonomie:erreur_recherche_aucun_taxon');
    240248                                        }
    241249                                } else {
    … …  
    243251                                }
    244252                        } else {
    245                                 $erreurs['message_erreur'] = _T('taxonomie:erreur_recherche_aucun_taxon');
     253                                $erreurs['recherche'] = _T('taxonomie:erreur_recherche_nom_scientifique');
    246254                        }
    247255                } else {
    248                         $erreurs['recherche'] = _T('taxonomie:erreur_recherche_nom_scientifique');
    249                 }
    250         } else {
    251                 $erreurs['recherche'] = _T('info_obligatoire');
     256                        $erreurs['recherche'] = _T('info_obligatoire');
     257                }
    252258        }
    253259
    … …  
    276282        $erreurs = array();
    277283
     284        // Il est cette fois indispensable de vérifier à nouveau les valeurs de l'étape 2 si on est dans une l'étape 3
     285        // car on a besoin de l'espèce et de ses ascendants jusqu'au genre compris.
    278286        if ($tsn = intval(_request('tsn'))) {
    279287                // On récupère les informations de base du taxon afin de les présenter à l'utilisateur pour validation
    … …  
    298306
    299307                // On récupère la hiérarchie complète du taxon à partir de la base ITIS.
    300                 $hierarchie = itis_get_information('hierarchyfull', $espece['tsn']);
    301                 $ascendants = $hierarchie['ascendants'];
     308                // Comme la hiérarchie intègre aussi le taxon concerné on le supprime (dernière position).
     309                $ascendants = itis_get_information('hierarchyfull', $espece['tsn']);
     310                unset($ascendants[count($ascendants) - 1]);
    302311
    303312                // On classe la liste des ascendants du plus proche au plus éloigné.
    … …  
    355364
    356365                // On range la liste des taxons de plus haut rang (genre) à celui de plus petit rang et on ajoute le
    357                 // taxon espèce en fin de liste.
     366                // taxon espèce en fin de liste. La variable _parents est toujours un tableau d'au moins une unité et
     367                // l'espèce existe toujours.
    358368                $taxons = _request('_parents');
    359369                $taxons[] = _request('_espece');

  • _plugins_/taxonomie/trunk/services/itis/itis_api.php

    r113783 r113806  
    506506                                $information = array();
    507507                                if (!empty($data)) {
     508                                        // On vérifie si une fonction de post-formatage existe
    508509                                        $format = "itis_format_$action";
    509                                         if (function_exists($format)) {
    510                                                 $information = $format($tsn, $data, $index);
    511                                         } else {
    512                                                 foreach ($data as $_data) {
    513                                                         $item = array();
    514                                                         foreach ($index as $_key_information => $_key_data) {
    515                                                                 $item[$_key_information] = $_data[$_key_data];
    516                                                         }
    517                                                         $information[] = $item;
     510                                        if (!function_exists($format)) {
     511                                                $format = '';
     512                                        }
     513                                        foreach ($data as $_data) {
     514                                                $item = array();
     515                                                // On construit le tableau de l'item brut correspondant à la configuration de l'action
     516                                                foreach ($index as $_key_information => $_key_data) {
     517                                                        $item[$_key_information] = $_data[$_key_data];
    518518                                                }
     519                                                // Si un formatage existe on formate l'item avant de l'ajouter au tableau de sortie.
     520                                                $information[] = $format ? $format($item) : $item;
    519521                                        }
    520522                                }
    … …  
    911913
    912914// ----------------------------------------------------------------
     915// ---------- Fonctions internes de formatage des sorties ---------
     916// ----------------------------------------------------------------
     917
     918/**
     919 * Formatage d'un item de la liste des ascendants d'un taxon.
     920 *
     921 * @internal
     922 *
     923 * @param array $item
     924 *        Tableau extrait du service get et représentant un taxon ascendant. Les valeurs sont insérées btutes.
     925 *
     926 * @return array
     927 *        Tableau dont les valeurs ont été formatées (rang taxonomique en minuscules).
     928 */
     929function itis_format_hierarchyfull($item) {
     930
     931        // Le formatage d'un item de la hiérarchie consiste uniquement à passer en minuscule l'identifiant du rang.
     932        if (isset($item['rang_taxon'])) {
     933                $item['rang_taxon'] = strtolower($item['rang_taxon']);
     934        }
     935
     936        return $item;
     937}
     938
     939
     940// ----------------------------------------------------------------
    913941// ------------ Fonctions internes utilisées par l'API ------------
    914942// ----------------------------------------------------------------
Note: See TracChangeset for help on using the changeset viewer.