Changeset 108487 in spip-zone


Ignore:
Timestamp:
Jan 13, 2018, 11:11:35 AM (3 years ago)
Author:
eric@…
Message:

Renommage, refactoring et introduction de la gestion des rangs autres que principaux.

Location:
_plugins_/taxonomie/trunk
Files:
5 added
5 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/taxonomie/trunk/inc/taxonomer.php

    r108385 r108487  
    33 * Ce fichier contient l'ensemble des constantes et des utilitaires nécessaires au fonctionnement du plugin.
    44 *
    5  * @package SPIP\TAXONOMIE
     5 * @package SPIP\TAXONOMIE\TAXON
    66 */
    77if (!defined('_ECRIRE_INC_VERSION')) {
     
    3333         */
    3434        define('_TAXONOMIE_REGNES',
    35                 implode(':', array(
    36                         _TAXONOMIE_REGNE_ANIMAL,
    37                         _TAXONOMIE_REGNE_VEGETAL,
    38                         _TAXONOMIE_REGNE_FONGIQUE
    39                 )));
     35                _TAXONOMIE_REGNE_ANIMAL . ':' .
     36                _TAXONOMIE_REGNE_VEGETAL . ':' .
     37                _TAXONOMIE_REGNE_FONGIQUE
     38        );
    4039}
    4140
     
    172171                _TAXONOMIE_RANGS_PARENTS_ESPECE . ':' . _TAXONOMIE_RANGS_ESPECE_ET_FILS);
    173172}
    174 
    175 if (!defined('_TAXONOMIE_CACHE_NOMDIR')) {
    176         /**
    177          * Nom du dossier contenant les fichiers caches des éléments de taxonomie
    178          *
    179          * @package SPIP\TAXONOMIE\CACHE
    180          */
    181         define('_TAXONOMIE_CACHE_NOMDIR', 'cache-taxonomie/');
    182 }
    183 if (!defined('_TAXONOMIE_CACHE_DIR')) {
    184         /**
    185          * Chemin du dossier contenant les fichiers caches des boussoles
    186          *
    187          * @package SPIP\TAXONOMIE\CACHE
    188          */
    189         define('_TAXONOMIE_CACHE_DIR', _DIR_VAR . _TAXONOMIE_CACHE_NOMDIR);
    190 }
    191 if (!defined('_TAXONOMIE_CACHE_FORCER')) {
    192         /**
    193          * Indicateur permettant de focer le recalcul du cache systématiquement.
    194          * A n'utiliser que temporairement en mode debug par exemple.
    195          *
    196          * @package SPIP\TAXONOMIE\CACHE
    197          */
    198         define('_TAXONOMIE_CACHE_FORCER', false);
    199 }
    200 
    201 
    202 /**
    203  * Renvoie, à partir de l'url du service, le tableau des données demandées.
    204  * Le service utilise dans ce cas une chaine JSON qui est décodée pour fournir
    205  * le tableau de sortie. Le flux retourné par le service est systématiquement
    206  * transcodé dans le charset du site avant d'être décodé.
    207  *
    208  * @package SPIP\TAXONOMIE\SERVICES
    209  * @uses recuperer_url()
    210  *
    211  * @param string   $url
    212  *        URL complète de la requête au service web concerné.
    213  * @param int|null $taille_max
    214  *        Taille maximale du flux récupéré suite à la requête.
    215  *        `null` désigne la taille par défaut.
    216  *
    217  * @return array
    218  */
    219 function service_requeter_json($url, $taille_max = null) {
    220 
    221         // Acquisition des données spécifiées par l'url
    222         include_spip('inc/distant');
    223         $options = array(
    224                 'transcoder' => true,
    225                 'taille_max' => $taille_max);
    226         $flux = recuperer_url($url, $options);
    227 
    228         // Tranformation de la chaine json reçue en tableau associatif
    229         $data = json_decode($flux['page'], true);
    230 
    231         return $data;
     173if (!defined('_TAXONOMIE_RANG_TYPE_PRINCIPAL')) {
     174        /**
     175         * Type de rang selon la nomenclature taxonomique.
     176         */
     177        define('_TAXONOMIE_RANG_TYPE_PRINCIPAL', 'principal');
     178}
     179if (!defined('_TAXONOMIE_RANG_TYPE_SECONDAIRE')) {
     180        /**
     181         * Type de rang selon la nomenclature taxonomique.
     182         */
     183        define('_TAXONOMIE_RANG_TYPE_SECONDAIRE', 'secondaire');
     184}
     185if (!defined('_TAXONOMIE_RANG_TYPE_INTERCALAIRE')) {
     186        /**
     187         * Type de rang selon la nomenclature taxonomique.
     188         */
     189        define('_TAXONOMIE_RANG_TYPE_INTERCALAIRE', 'intercalaire');
    232190}
    233191
     
    236194 * Extrait, de la table `spip_taxons`, la liste des taxons d'un règne donné ayant fait l'objet
    237195 * d'une modification manuelle.
    238  *
    239  * @package SPIP\TAXONOMIE\TAXON
    240196 *
    241197 * @param string $regne
     
    262218 * Si on ne trouve pas de balise `<multi>` dans l'un ou l'autre des paramètres, on considère que
    263219 * le texte est tout même formaté de la façon suivante : texte0[langue1]texte1[langue2]texte2...
    264  *
    265  * @package SPIP\TAXONOMIE\TAXON
    266220 *
    267221 * @param string $multi_prioritaire
     
    329283 * Traduit un champ de la table `spip_taxons` dans la langue du site.
    330284 *
    331  * @package SPIP\TAXONOMIE\TAXON
    332  *
    333285 * @param $champ
    334286 *        Nom du champ dans la base de données.
     
    346298        return $traduction;
    347299}
    348 
    349 
    350 /**
    351  * Ecrit le contenu issu d'un service taxonomique dans un fichier texte afin d'optimiser le nombre
    352  * de requêtes adressées au service.
    353  *
    354  * @package SPIP\TAXONOMIE\CACHE
    355  *
    356  * @param string $cache
    357  *        Contenu du fichier cache. Si le service appelant manipule un tableau il doit le sérialiser avant
    358  *        d'appeler cette fonction.
    359  * @param string $service
    360  * @param string $action
    361  * @param int    $tsn
    362  * @param array  $options
    363  *
    364  * @return boolean
    365  *        Toujours à vrai.
    366  */
    367 function cache_taxonomie_ecrire($cache, $service, $action, $tsn, $options) {
    368 
    369         // Création du dossier cache si besoin
    370         sous_repertoire(_DIR_VAR, trim(_TAXONOMIE_CACHE_NOMDIR, '/'));
    371 
    372         // Ecriture du fichier cache
    373         $fichier_cache = cache_taxonomie_nommer($service, $tsn, $action, $options);
    374         ecrire_fichier($fichier_cache, $cache);
    375 
    376         return true;
    377 }
    378 
    379 
    380 /**
    381  * Construit le nom du fichier cache en fonction du service, de l'action, du taxon concernés et
    382  * d'autres critères optionnels.
    383  *
    384  * @package SPIP\TAXONOMIE\CACHE
    385  *
    386  * @param string $service
    387  * @param string $action
    388  * @param int    $tsn
    389  * @param array  $options
    390  *
    391  * @return string
    392  */
    393 function cache_taxonomie_nommer($service, $action, $tsn, $options) {
    394 
    395         // Construction du chemin complet d'un fichier cache
    396         $fichier_cache = _TAXONOMIE_CACHE_DIR
    397                                          . $service
    398                                          . ($action ? '_' . $action : '')
    399                                          . '_' . $tsn;
    400 
    401         // On complète le nom avec les options éventuelles
    402         if ($options) {
    403                 foreach ($options as $_option => $_valeur) {
    404                         if ($_valeur) {
    405                                 $fichier_cache .= '_' . $_valeur;
    406                         }
    407                 }
    408         }
    409 
    410         // On rajoute l'extension texte
    411         $fichier_cache .= '.txt';
    412 
    413         return $fichier_cache;
    414 }
    415 
    416 /**
    417  * Vérifie l'existence du fichier cache pour un taxon, un service et une actions donnés.
    418  * Si le fichier existe la fonction retourne son chemin complet.
    419  *
    420  * @package SPIP\TAXONOMIE\CACHE
    421  *
    422  * @param string $service
    423  * @param string $action
    424  * @param int    $tsn
    425  * @param array  $options
    426  *
    427  * @return string
    428  *        Chemin du fichier cache si il existe ou chaine vide sinon.
    429  */
    430 function cache_taxonomie_existe($service, $action, $tsn, $options = array()) {
    431 
    432         // Contruire le nom du fichier cache
    433         $fichier_cache = cache_taxonomie_nommer($service, $action, $tsn, $options);
    434 
    435         // Vérification de l'existence du fichier:
    436         // - chaine vide si le fichier n'existe pas
    437         // - chemin complet du fichier si il existe
    438         if (!file_exists($fichier_cache)) {
    439                 $fichier_cache = '';
    440         }
    441 
    442         return $fichier_cache;
    443 }
    444 
    445 
    446 /**
    447  * Supprime tout ou partie des fichiers cache taxonomiques.
    448  *
    449  * @package SPIP\TAXONOMIE\CACHE
    450  *
    451  * @param array|string $caches
    452  *        Liste des fichiers à supprimer ou vide si tous les fichiers cache doivent être supprimés.
    453  *        Il est possible de passer un seul fichier comme une chaine.
    454  *
    455  * @return boolean
    456  *        Toujours à `true`.
    457  */
    458 function cache_taxonomie_supprimer($caches = array()) {
    459 
    460         include_spip('inc/flock');
    461 
    462         if ($caches) {
    463                 $fichiers_cache = is_string($caches) ? array($caches) : $caches;
    464         } else {
    465                 $fichiers_cache = glob(_TAXONOMIE_CACHE_DIR . '*.*');
    466         }
    467 
    468         if ($fichiers_cache) {
    469                 foreach ($fichiers_cache as $_fichier) {
    470                         supprimer_fichier($_fichier);
    471                 }
    472         }
    473 
    474         return true;
    475 }
  • _plugins_/taxonomie/trunk/services/itis/itis_api.php

    r108375 r108487  
    204204
    205205        // Acquisition des données spécifiées par l'url
    206         include_spip('inc/taxonomer');
    207         $data = service_requeter_json($url);
     206        $requeter = charger_fonction('taxonomie_requeter', 'inc');
     207        $data = $requeter($url);
    208208
    209209        // Récupération du TSN du taxon recherché
     
    218218                foreach ($data[$api['list']] as $_data) {
    219219                        if ($_data) {
    220                                 if (!$strict
    221                                         or ($strict and (strcasecmp($_data[$search_key], $search) == 0))
    222                                 ) {
     220                                if (!$strict or ($strict and (strcasecmp($_data[$search_key], $search) == 0))) {
    223221                                        $tsn[] = array(
    224222                                                $tsn_destination    => intval($_data[$tsn_key]),
     
    265263
    266264        // Acquisition des données spécifiées par l'url
    267         include_spip('inc/taxonomer');
    268         $data = service_requeter_json($url);
     265        $requeter = charger_fonction('taxonomie_requeter', 'inc');
     266        $data = $requeter($url);
    269267
    270268        // Récupération des informations choisies parmi l'enregistrement reçu à partir de la configuration
     
    282280        // On réorganise le sous-tableau des noms communs
    283281        $noms = array();
    284         if (is_array($record['nom_commun'])
    285                 and $record['nom_commun']
    286         ) {
     282        if (is_array($record['nom_commun'])     and $record['nom_commun']) {
    287283                foreach ($record['nom_commun'] as $_nom) {
    288284                        $noms[strtolower($_nom['language'])] = trim($_nom['commonName']);
     
    328324
    329325        // Acquisition des données spécifiées par l'url
    330         include_spip('inc/taxonomer');
    331         $data = service_requeter_json($url);
     326        $requeter = charger_fonction('taxonomie_requeter', 'inc');
     327        $data = $requeter($url);
    332328
    333329        // On vérifie que le tableau est complet sinon on retourne un tableau vide
     
    397393
    398394        // Acquisition des données spécifiées par l'url
    399         include_spip('inc/taxonomer');
    400395        include_spip('inc/distant');
    401         $data = service_requeter_json($url, _INC_DISTANT_MAX_SIZE * 7);
     396        $requeter = charger_fonction('taxonomie_requeter', 'inc');
     397        $data = $requeter($url, _INC_DISTANT_MAX_SIZE * 7);
    402398
    403399        $api = $GLOBALS['itis_webservice']['vernacular']['vernacularlanguage'];
     
    556552        // Ouvrir le fichier de nom communs correspondant au code de langue spécifié
    557553        $file = find_in_path("services/itis/vernaculars_${language}.csv");
    558         if (file_exists($file)
    559                 and ($sha_file = sha1_file($file))
    560         ) {
     554        if (file_exists($file) and ($sha_file = sha1_file($file))) {
    561555                // Lecture du fichier csv comme un fichier texte sachant que :
    562556                // - le délimiteur de colonne est une virgule
     
    577571
    578572
     573/**
     574 * Lit le fichier des rangs d'un règne donné et construit la hiérarchie de ces mêmes rangs.
     575 *
     576 * @api
     577 *
     578 * @param string $kingdom
     579 *        Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
     580 * @param int    $sha_file
     581 *        Sha calculé à partir du fichier de taxons correspondant au règne choisi. Le sha est retourné
     582 *        par la fonction afin d'être stocké par le plugin.
     583 *
     584 * @return array
     585 *        Tableau des rangs identifiés par leur nom scientifique en anglais et organisé comme une hiérarchie
     586 *        du règne au rang de plus bas niveau.
     587 */
     588function itis_read_ranks($kingdom, &$sha_file) {
     589
     590        $ranks = array();
     591        $sha_file = false;
     592
     593        // Ouvrir le fichier des rangs du règne spécifié.
     594        $file = find_in_path("services/itis/${kingdom}_ranks.json");
     595        if (file_exists($file) and ($sha_file = sha1_file($file))) {
     596                // Lecture du fichier json et décodage en tableau.
     597                include_spip('inc/flock');
     598                lire_fichier($file, $content);
     599                if ($content) {
     600                        $itis_ranks = json_decode($content, true);
     601                        if ($itis_ranks) {
     602                                // On acquiert la configuration du plugin
     603                                include_spip('inc/config');
     604                                $configuration = lire_config('taxonomie', array());
     605
     606                                // Le fichier est toujours classé du règne au rang fils le plus bas dans l'arborescence.
     607                                // On peut donc être assuré que le parent d'un rang donné a toujours été préalablement
     608                                // traité sauf le premier, le règne.
     609                                include_spip('inc/taxonomer');
     610                                $rank_ids = array();
     611                                foreach ($itis_ranks as $_rank) {
     612                                        $rank_name = strtolower($_rank['rank_name']);
     613                                        // -- Détermination des parents
     614                                        if (isset($rank_ids[$_rank['dir_parent_rank_id']]) and isset($rank_ids[$_rank['req_parent_rank_id']])) {
     615                                                // Cas des rangs enfant du règne.
     616                                                $ranks[$rank_name] = array(
     617                                                        'parent' => $rank_ids[$_rank['dir_parent_rank_id']],
     618                                                        'parent_principal' => $rank_ids[$_rank['req_parent_rank_id']]
     619                                                );
     620                                        } else {
     621                                                // Cas du règne qui n'a pas de parent.
     622                                                $ranks[$rank_name] = array(
     623                                                        'parent' => '',
     624                                                        'parent_principal' => ''
     625                                                );
     626                                        }
     627                                        // -- Détermination du type de rang
     628                                        if (in_array($rank_name, $configuration['rangs_principaux'])) {
     629                                                $ranks[$rank_name]['type'] = _TAXONOMIE_RANG_TYPE_PRINCIPAL;
     630                                        } elseif (in_array($rank_name, $configuration['rangs_secondaires'])) {
     631                                                $ranks[$rank_name]['type'] = _TAXONOMIE_RANG_TYPE_SECONDAIRE;
     632                                        } else{
     633                                                $ranks[$rank_name]['type'] = _TAXONOMIE_RANG_TYPE_INTERCALAIRE;
     634                                        }
     635
     636                                        // -- Sauvegarde de l'id ITIS du rang traité pour les descendants.
     637                                        $rank_ids[$_rank['rank_id']] = $rank_name;
     638                                }
     639                        }
     640                }
     641        }
     642
     643        return $ranks;
     644}
     645
     646
    579647// ---------------------------------------------------------------------
    580648// ------------ API du web service ITIS - Fonctions annexes ------------
     
    656724        foreach ($kingdoms as $_kingdom) {
    657725                $file = find_in_path('services/itis/' . ucfirst($_kingdom) . '_Genus.txt');
    658                 if (file_exists($file)
    659                         and ($sha_file = sha1_file($file))
    660                 ) {
     726                if (file_exists($file) and ($sha_file = sha1_file($file))) {
    661727                        $shas['taxons'][$_kingdom] = $sha_file;
    662728                }
     
    665731        foreach (array_keys($GLOBALS['itis_language']) as $_language) {
    666732                $file = find_in_path("services/itis/vernaculars_${_language}.csv");
    667                 if (file_exists($file)
    668                         and ($sha_file = sha1_file($file))
    669                 ) {
     733                if (file_exists($file) and ($sha_file = sha1_file($file))) {
    670734                        $shas['traductions'][$GLOBALS['itis_language'][$_language]] = $sha_file;
    671735                }
  • _plugins_/taxonomie/trunk/services/wikipedia/wikipedia_api.php

    r108375 r108487  
    8888        // Si le cache est absent ou invalide on le recrée en utilisant le service web Wikipedia
    8989        // sinon on le lit et on renvoie le tableau du contenu désérialisé.
    90         include_spip('inc/taxonomer');
     90        include_spip('inc/taxonomie_cacher');
    9191        if (!$file_cache = cache_taxonomie_existe('wikipedia', $resource, $tsn, $options)
    9292        or !filemtime($file_cache)
     
    101101
    102102                // Acquisition des données spécifiées par l'url
    103                 $data = service_requeter_json($url);
     103                $requeter = charger_fonction('taxonomie_requeter', 'inc');
     104                $data = $requeter($url);
    104105
    105106                // Récupération de la section demandée.
  • _plugins_/taxonomie/trunk/taxonomie_administrations.php

    r108385 r108487  
    7575                'langues_possibles' => array('fr', 'en', 'es'),
    7676                'langues_utilisees' => array('fr'),
     77                'rangs_principaux'  => array('kingdom', 'phylum', 'class', 'order', 'family', 'genus', 'species'),
     78                'rangs_secondaires' => array('tribe', 'section', 'series', 'variety', 'form'),
    7779        );
    7880
  • _plugins_/taxonomie/trunk/taxonomie_fonctions.php

    r108385 r108487  
    116116                        $meta_regne['rang'] = $rang;
    117117                        $meta_regne['maj'] = date('Y-m-d H:i:s');
    118                         ecrire_meta("taxonomie_$regne", serialize($meta_regne));
     118
     119                        // Lire le fichier json fournissant la hiérarchie des rangs du règne en cours de chargement.
     120                        $rangs = itis_read_ranks($regne, $sha_rangs);
     121                        $meta_regne['rangs']['hierarchie'] = $rangs;
     122                        $meta_regne['rangs']['sha'] = $sha_rangs;
     123
     124                        // Mise à jour de la meta du règne.
     125                        include_spip('inc/config');
     126                        ecrire_config("taxonomie_$regne", $meta_regne);
    119127                }
    120128        }
Note: See TracChangeset for help on using the changeset viewer.