Changeset 96992 in spip-zone


Ignore:
Timestamp:
May 5, 2016, 2:41:30 PM (3 years ago)
Author:
eric@…
Message:

Phpdoc et formatage PSR SPIP

Location:
_plugins_/taxonomie/trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/taxonomie/trunk/action/taxonomie_get_wikipedia.php

    r93223 r96992  
    66 * @package SPIP\TAXONOMIE\SERVICES\WIKIPEDIA
    77 */
    8 
    9 if (!defined('_ECRIRE_INC_VERSION')) return;
     8if (!defined('_ECRIRE_INC_VERSION')) {
     9        return;
     10}
    1011
    1112/**
     
    2425 * @return void
    2526 */
    26 function action_taxonomie_get_wikipedia_dist(){
     27function action_taxonomie_get_wikipedia_dist() {
    2728
    2829        // Securisation et autorisation car c'est une action auteur:
     
    4748                if (intval($id_taxon)) {
    4849                        // Récupération des informations tsn, source et edite du taxon
    49                         $taxon = sql_fetsel(array('tsn', 'sources', 'edite', $champ), 'spip_taxons', 'id_taxon='. sql_quote($id_taxon));
     50                        $taxon = sql_fetsel(array('tsn', 'sources', 'edite', $champ), 'spip_taxons', 'id_taxon=' . sql_quote($id_taxon));
    5051
    5152                        // Appel du service query de Wikipedia
     
    5960                                $convertir = chercher_filtre('convertisseur_texte_spip');
    6061                                $texte_converti = '<multi>'
    61                                         . '[' . $spip_langue .']'
    62                                         . ($convertir ? $convertir($information['texte'], 'MediaWiki_SPIP') : $information['texte'])
    63                                         . '</multi>';
     62                                                                  . '[' . $spip_langue . ']'
     63                                                                  . ($convertir ? $convertir($information['texte'], 'MediaWiki_SPIP') : $information['texte'])
     64                                                                  . '</multi>';
    6465
    6566                                // Mise à jour pour le taxon du descriptif et des champs connexes en base de données
     
    8081                                $maj['sources'] = serialize($maj['sources']);
    8182                                // - Mise à jour
    82                                 sql_updateq('spip_taxons', $maj, 'id_taxon='. sql_quote($id_taxon));
     83                                sql_updateq('spip_taxons', $maj, 'id_taxon=' . sql_quote($id_taxon));
    8384                        }
    8485                }
    8586        }
    8687}
    87 
    88 ?>
  • _plugins_/taxonomie/trunk/base/taxonomie_declarations.php

    r93059 r96992  
    55 * @package SPIP\TAXONOMIE\ADMINISTRATION
    66 */
    7 
    8 if (!defined('_ECRIRE_INC_VERSION')) return;
     7if (!defined('_ECRIRE_INC_VERSION')) {
     8        return;
     9}
    910
    1011
     
    1516 *
    1617 * @param array $interfaces
    17  *              Déclarations d'interface pour le compilateur.
     18 *        Déclarations d'interface pour le compilateur.
    1819 *
    1920 * @return array
    20  *              Déclarations d'interface pour le compilateur mises à jour.
     21 *        Déclarations d'interface pour le compilateur mises à jour.
    2122 */
    2223function taxonomie_declarer_tables_interfaces($interfaces) {
     
    3536 * Les taxons à partir de l'espèce ne font pas partie de cette table. Les champs principaux sont les
    3637 * suivants :
    37  *              - `nom_scientifique` est le nom en latin. Il est unique pour un rang taxonomique donné.
    38  *              - `rang` taxonomique est une valeur parmi `kingdom`, `phylum`, `class`, `order`, `family` et `genus`.
    39  *              - `nom_commun` est le nom vulgaire, si possible normalisé par une commission officielle. Il peut coincider ou pas
    40  *              avec le nom vernaculaire.
    41  *              - `auteur` est une information composée d'un ou plusieurs noms complétés par une date (ex : Linneus, 1798).
    42  *              - `tsn` est l'identifiant numérique unique du taxon dans la base taxonomique ITIS.
    43  *              - `tsn_parent` permet de créer l'arborescence taxonomique du règne conformément à l'organisation de la base ITIS.
     38 *        - `nom_scientifique` est le nom en latin. Il est unique pour un rang taxonomique donné.
     39 *        - `rang` taxonomique est une valeur parmi `kingdom`, `phylum`, `class`, `order`, `family` et `genus`.
     40 *        - `nom_commun` est le nom vulgaire, si possible normalisé par une commission officielle. Il peut coincider ou
     41 *        pas avec le nom vernaculaire.
     42 *        - `auteur` est une information composée d'un ou plusieurs noms complétés par une date (ex : Linneus, 1798).
     43 *        - `tsn` est l'identifiant numérique unique du taxon dans la base taxonomique ITIS.
     44 *        - `tsn_parent` permet de créer l'arborescence taxonomique du règne conformément à l'organisation de la base
     45 *        ITIS.
    4446 *
    4547 * @pipeline declarer_tables_objets_sql
    4648 *
    4749 * @param array $tables
    48  *              Description des tables de la base.
     50 *        Description des tables de la base.
    4951 *
    5052 * @return array
    51  *              Description des tables de la base complétée par celles du plugin.
     53 *        Description des tables de la base complétée par celles du plugin.
    5254 */
    5355function taxonomie_declarer_tables_objets_sql($tables) {
     
    5658         */
    5759        $tables['spip_taxons'] = array(
    58                 'type' => 'taxon',
    59                 'principale' => "oui",
    60                 'field'=> array(
    61                         "id_taxon"                      => "bigint(21) NOT NULL",
    62                         "nom_scientifique"      => "varchar(35) DEFAULT '' NOT NULL",
    63                         "rang"                          => "varchar(15) DEFAULT '' NOT NULL",
    64                         "regne"                         => "varchar(10) DEFAULT '' NOT NULL",
    65                         "nom_commun"            => "text DEFAULT '' NOT NULL",
    66                         "auteur"                        => "varchar(100) DEFAULT '' NOT NULL",
    67                         "descriptif"            => "text DEFAULT '' NOT NULL",
    68                         "tsn"                           => "bigint(21) NOT NULL",
    69                         "tsn_parent"            => "bigint(21) NOT NULL",
    70                         "sources"                       => "text DEFAULT '' NOT NULL",
    71                         "edite"                         => "varchar(3) DEFAULT 'non' NOT NULL",
    72                         "maj"                           => "TIMESTAMP"
     60                'type'       => 'taxon',
     61                'principale' => 'oui',
     62                'field'      => array(
     63                        'id_taxon'         => 'bigint(21) NOT NULL',
     64                        'nom_scientifique' => "varchar(35) DEFAULT '' NOT NULL",
     65                        'rang'             => "varchar(15) DEFAULT '' NOT NULL",
     66                        'regne'            => "varchar(10) DEFAULT '' NOT NULL",
     67                        'nom_commun'       => "text DEFAULT '' NOT NULL",
     68                        'auteur'           => "varchar(100) DEFAULT '' NOT NULL",
     69                        'descriptif'       => "text DEFAULT '' NOT NULL",
     70                        'tsn'              => 'bigint(21) NOT NULL',
     71                        'tsn_parent'       => 'bigint(21) NOT NULL',
     72                        'sources'          => "text DEFAULT '' NOT NULL",
     73                        'edite'            => "varchar(3) DEFAULT 'non' NOT NULL",
     74                        'maj'              => 'TIMESTAMP'
    7375                ),
    74                 'key' => array(
    75                         "PRIMARY KEY"           => "id_taxon",
    76                         "KEY tsn"                       => "tsn",
     76                'key'        => array(
     77                        'PRIMARY KEY' => 'id_taxon',
     78                        'KEY tsn'     => 'tsn',
    7779                ),
    78                 'titre' => "nom_scientifique AS titre, '' AS lang",
     80                'titre'      => "nom_scientifique AS titre, '' AS lang",
    7981
    8082                'champs_editables'  => array('nom_commun', 'descriptif'),
    8183                'champs_versionnes' => array('nom_commun', 'descriptif'),
    82                 'rechercher_champs' => array("nom_scientifique" => 10, "nom_commun" => 10, "descriptif" => 5),
     84                'rechercher_champs' => array('nom_scientifique' => 10, 'nom_commun' => 10, 'descriptif' => 5),
    8385                'tables_jointures'  => array(),
    8486        );
     
    8688        return $tables;
    8789}
    88 
    89 ?>
  • _plugins_/taxonomie/trunk/genie/taxonomie_actualiser_itis.php

    r93059 r96992  
    55 * @package    SPIP\TAXONOMIE\SERVICES\ITIS
    66 */
    7 
    8 if (!defined("_ECRIRE_INC_VERSION")) return;
     7if (!defined('_ECRIRE_INC_VERSION')) {
     8        return;
     9}
    910
    1011/**
     
    2122 * @uses taxonomie_charger_regne()
    2223 *
    23  * @param int   $last
    24  *              Timestamp de la date de dernier appel de la tâche.
     24 * @param int $last
     25 *        Timestamp de la date de dernier appel de la tâche.
    2526 *
    2627 * @return int
    27  *              Timestamp de la date du prochain appel de la tâche.
     28 *        Timestamp de la date du prochain appel de la tâche.
    2829 */
    2930function genie_taxonomie_actualiser_itis_dist($last) {
     
    4243                        if ($meta_regne['sha'] != $shas['taxons'][$_regne]) {
    4344                                $regne_a_recharger = true;
    44                         }
    45                         else {
     45                        } else {
    4646                                // On compare le sha des fichiers de traductions
    4747                                foreach ($meta_regne['traductions']['itis'] as $_code => $_infos) {
     
    6161        return 1;
    6262}
    63 
    64 ?>
  • _plugins_/taxonomie/trunk/inc/taxonomer.php

    r93093 r96992  
    55 * @package SPIP\TAXONOMIE
    66 */
    7 
    8 if (!defined("_ECRIRE_INC_VERSION")) return;
    9 
    10 if (!defined('_TAXONOMIE_REGNE_ANIMAL'))
     7if (!defined('_ECRIRE_INC_VERSION')) {
     8        return;
     9}
     10
     11if (!defined('_TAXONOMIE_REGNE_ANIMAL')) {
    1112        /**
    1213         * Nom latin du règne animal (animaux).
    1314         */
    1415        define('_TAXONOMIE_REGNE_ANIMAL', 'animalia');
    15 if (!defined('_TAXONOMIE_REGNE_VEGETAL'))
     16}
     17if (!defined('_TAXONOMIE_REGNE_VEGETAL')) {
    1618        /**
    1719         * Nom latin du règne végétal (plantes).
    1820         */
    1921        define('_TAXONOMIE_REGNE_VEGETAL', 'plantae');
    20 if (!defined('_TAXONOMIE_REGNE_FONGIQUE'))
     22}
     23if (!defined('_TAXONOMIE_REGNE_FONGIQUE')) {
    2124        /**
    2225         * Nom latin du règne fongique (champignons).
    2326         */
    2427        define('_TAXONOMIE_REGNE_FONGIQUE', 'fungi');
    25 
    26 if (!defined('_TAXONOMIE_REGNES'))
     28}
     29
     30if (!defined('_TAXONOMIE_REGNES')) {
    2731        /**
    2832         * Liste des règnes supportés par le plugin (concanétation des noms séparés par le signe deux-points).
     
    3438                        _TAXONOMIE_REGNE_FONGIQUE
    3539                )));
    36 
    37 if (!defined('_TAXONOMIE_RANG_REGNE'))
     40}
     41
     42if (!defined('_TAXONOMIE_RANG_REGNE')) {
    3843        /**
    3944         * Nom anglais du rang `règne`.
    4045         */
    4146        define('_TAXONOMIE_RANG_REGNE', 'kingdom');
     47}
    4248// Suivant le règne l'embranchement se nomme phylum (animalia) ou division (fungi, plantae).
    4349// Néanmoins, le terme phylum est souvent accepté pour l'ensemble des règnes
    44 if (!defined('_TAXONOMIE_RANG_PHYLUM'))
     50if (!defined('_TAXONOMIE_RANG_PHYLUM')) {
    4551        /**
    4652         * Nom anglais du rang `phylum` ou `embranchement`.
     
    4854         */
    4955        define('_TAXONOMIE_RANG_PHYLUM', 'phylum');
    50 if (!defined('_TAXONOMIE_RANG_DIVISION'))
     56}
     57if (!defined('_TAXONOMIE_RANG_DIVISION')) {
    5158        /**
    5259         * Nom anglais du rang `division`.
     
    5461         */
    5562        define('_TAXONOMIE_RANG_DIVISION', 'division');
    56 if (!defined('_TAXONOMIE_RANG_CLASSE'))
     63}
     64if (!defined('_TAXONOMIE_RANG_CLASSE')) {
    5765        /**
    5866         * Nom anglais du rang `classe`.
    5967         */
    6068        define('_TAXONOMIE_RANG_CLASSE', 'class');
    61 if (!defined('_TAXONOMIE_RANG_ORDRE'))
     69}
     70if (!defined('_TAXONOMIE_RANG_ORDRE')) {
    6271        /**
    6372         * Nom anglais du rang `ordre`.
    6473         */
    6574        define('_TAXONOMIE_RANG_ORDRE', 'order');
    66 if (!defined('_TAXONOMIE_RANG_FAMILLE'))
     75}
     76if (!defined('_TAXONOMIE_RANG_FAMILLE')) {
    6777        /**
    6878         * Nom anglais du rang `famille`.
    6979         */
    7080        define('_TAXONOMIE_RANG_FAMILLE', 'family');
    71 if (!defined('_TAXONOMIE_RANG_GENRE'))
     81}
     82if (!defined('_TAXONOMIE_RANG_GENRE')) {
    7283        /**
    7384         * Nom anglais du rang `genre`.
    7485         */
    7586        define('_TAXONOMIE_RANG_GENRE', 'genus');
    76 if (!defined('_TAXONOMIE_RANG_ESPECE'))
     87}
     88if (!defined('_TAXONOMIE_RANG_ESPECE')) {
    7789        /**
    7890         * Nom anglais du rang `espèce`.
    7991         */
    8092        define('_TAXONOMIE_RANG_ESPECE', 'species');
    81 if (!defined('_TAXONOMIE_RANG_SOUS_ESPECE'))
     93}
     94if (!defined('_TAXONOMIE_RANG_SOUS_ESPECE')) {
    8295        /**
    8396         * Nom anglais du rang intercalaire `sous-espèce`.
    8497         */
    8598        define('_TAXONOMIE_RANG_SOUS_ESPECE', 'subspecies');
    86 if (!defined('_TAXONOMIE_RANG_VARIETE'))
     99}
     100if (!defined('_TAXONOMIE_RANG_VARIETE')) {
    87101        /**
    88102         * Nom anglais du rang `variété`.
    89103         */
    90104        define('_TAXONOMIE_RANG_VARIETE', 'variety');
    91 if (!defined('_TAXONOMIE_RANG_SOUS_VARIETE'))
     105}
     106if (!defined('_TAXONOMIE_RANG_SOUS_VARIETE')) {
    92107        /**
    93108         * Nom anglais du rang intercalaire `sous-variété`.
    94109         */
    95110        define('_TAXONOMIE_RANG_SOUS_VARIETE', 'subvariety');
    96 if (!defined('_TAXONOMIE_RANG_RACE'))
     111}
     112if (!defined('_TAXONOMIE_RANG_RACE')) {
    97113        /**
    98114         * Nom anglais du rang `race`.
    99115         */
    100116        define('_TAXONOMIE_RANG_RACE', 'race');
    101 if (!defined('_TAXONOMIE_RANG_FORME'))
     117}
     118if (!defined('_TAXONOMIE_RANG_FORME')) {
    102119        /**
    103120         * Nom anglais du rang `forme`.
    104121         */
    105122        define('_TAXONOMIE_RANG_FORME', 'forma');
    106 if (!defined('_TAXONOMIE_RANG_SOUS_FORME'))
     123}
     124if (!defined('_TAXONOMIE_RANG_SOUS_FORME')) {
    107125        /**
    108126         * Nom anglais du rang intercalaire `sous-règne`.
    109127         */
    110128        define('_TAXONOMIE_RANG_SOUS_FORME', 'subforma');
    111 
    112 //
    113 if (!defined('_TAXONOMIE_RANGS_PARENTS_ESPECE'))
     129}
     130
     131if (!defined('_TAXONOMIE_RANGS_PARENTS_ESPECE')) {
    114132        /**
    115133         * Liste des rangs utilisés du règne au genre compris (concanétation des noms séparés par le signe deux-points).
     
    124142                        _TAXONOMIE_RANG_FAMILLE,
    125143                        _TAXONOMIE_RANG_GENRE
    126                 )));
    127 if (!defined('_TAXONOMIE_RANGS_ESPECE_ET_FILS'))
     144                        )
     145                )
     146        );
     147}
     148if (!defined('_TAXONOMIE_RANGS_ESPECE_ET_FILS')) {
    128149        /**
    129150         * Liste des rangs utilisés de l'espèce à la sous-forme (concanétation des noms séparés par le signe deux-points).
     
    138159                        _TAXONOMIE_RANG_FORME,
    139160                        _TAXONOMIE_RANG_SOUS_FORME
    140                 )));
    141 if (!defined('_TAXONOMIE_RANGS'))
     161                        )
     162                )
     163        );
     164}
     165if (!defined('_TAXONOMIE_RANGS')) {
    142166        /**
    143167         * Liste complète des rangs utilisés par le plugin (concanétation des noms séparés par le signe deux-points).
    144168         */
    145169        define('_TAXONOMIE_RANGS',
    146                 _TAXONOMIE_RANGS_PARENTS_ESPECE . ':' . _TAXONOMIE_RANGS_ESPECE_ET_FILS);
    147 
    148 if (!defined('_TAXONOMIE_CACHE_NOMDIR'))
     170                _TAXONOMIE_RANGS_PARENTS_ESPECE . ':' . _TAXONOMIE_RANGS_ESPECE_ET_FILS);
     171}
     172
     173if (!defined('_TAXONOMIE_CACHE_NOMDIR')) {
    149174        /**
    150175         * Nom du dossier contenant les fichiers caches des éléments de taxonomie
     
    153178         */
    154179        define('_TAXONOMIE_CACHE_NOMDIR', 'cache-taxonomie/');
    155 if (!defined('_TAXONOMIE_CACHE_DIR'))
     180}
     181if (!defined('_TAXONOMIE_CACHE_DIR')) {
    156182        /**
    157183         * Chemin du dossier contenant les fichiers caches des boussoles
     
    160186         */
    161187        define('_TAXONOMIE_CACHE_DIR', _DIR_VAR . _TAXONOMIE_CACHE_NOMDIR);
     188}
    162189
    163190
     
    169196 *
    170197 * @package SPIP\TAXONOMIE\SERVICES
    171  *
    172  * @param string        $url
    173  *              URL complète de la requête au service web concerné.
    174  * @param int|null      $taille_max
    175  *              Taille maximale di flux récupéré suite à la requête.
    176  *              `null` désigne la taille par défaut.
     198 * @uses recuperer_url()
     199 *
     200 * @param string   $url
     201 *        URL complète de la requête au service web concerné.
     202 * @param int|null $taille_max
     203 *        Taille maximale du flux récupéré suite à la requête.
     204 *        `null` désigne la taille par défaut.
    177205 *
    178206 * @return array
    179207 */
    180 function service_requeter_json($url, $taille_max=null) {
     208function service_requeter_json($url, $taille_max = null) {
    181209        // Acquisition des données spécifiées par l'url
    182210        include_spip('inc/distant');
    183         $flux = recuperer_page($url, true, false, $taille_max);
     211        $options = array(
     212                'transcoder' => true,
     213                'taille_max' => $taille_max);
     214        $flux = recuperer_url($url, $options);
    184215
    185216        // Tranformation de la chaine json reçue en tableau associatif
    186         $data = json_decode($flux, true);
     217        $data = json_decode($flux['page'], true);
    187218
    188219        return $data;
     
    196227 * @package SPIP\TAXONOMIE\OBJET
    197228 *
    198  * @param string        $regne
    199  *              Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
     229 * @param string $regne
     230 *        Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
    200231 *
    201232 * @return array
    202  *              Liste des taxons modifiées manuellement. Chaque élément de la liste est un tableau
    203  *              composé des index `tsn`, `nom_commun`, `descriptif`.
     233 *        Liste des taxons modifiées manuellement. Chaque élément de la liste est un tableau
     234 *        composé des index `tsn`, `nom_commun`, `descriptif`.
    204235 */
    205236function taxon_preserver_editions($regne) {
     
    221252 * @package SPIP\TAXONOMIE\OBJET
    222253 *
    223  * @param string        $multi_prioritaire
    224  *              Balise multi considérée comme prioritaire en cas de conflit sur une langue.
    225  * @param string        $multi_non_prioritaire
    226  *              Balise multi considérée comme non prioritaire en cas de conflit sur une langue.
     254 * @param string $multi_prioritaire
     255 *        Balise multi considérée comme prioritaire en cas de conflit sur une langue.
     256 * @param string $multi_non_prioritaire
     257 *        Balise multi considérée comme non prioritaire en cas de conflit sur une langue.
    227258 *
    228259 * @return string
    229  *              La chaine construite est toujours une balise `<multi>` complète ou une chaine vide sinon.
     260 *        La chaine construite est toujours une balise `<multi>` complète ou une chaine vide sinon.
    230261 */
    231262function taxon_merger_traductions($multi_prioritaire, $multi_non_prioritaire) {
     
    287318 *
    288319 * @param $champ
    289  *              Nom du champ dans la base de données.
     320 *        Nom du champ dans la base de données.
    290321 *
    291322 * @return string
    292  *              Traduction du champ dans la langue du site.
     323 *        Traduction du champ dans la langue du site.
    293324 */
    294325function taxon_traduire_champ($champ) {
     
    297328                $traduction = _T("taxon:champ_${champ}_label");
    298329        }
     330
    299331        return $traduction;
    300332}
     
    307339 * @package SPIP\TAXONOMIE\CACHE
    308340 *
    309  * @param string        $cache
    310  *              Contenu du fichier cache. Si le service appelant manipule un tableau il doit le sérialiser avant
    311  *      d'appeler cette fonction.
    312  * @param string    $service
    313  * @param int       $tsn
    314  * @param string    $spip_langue
    315  * @param string    $action
     341 * @param string $cache
     342 *        Contenu du fichier cache. Si le service appelant manipule un tableau il doit le sérialiser avant
     343 *        d'appeler cette fonction.
     344 * @param string $service
     345 * @param int    $tsn
     346 * @param string $spip_langue
     347 * @param string $action
    316348 *
    317349 * @return boolean
    318  *              Toujours à vrai.
    319  */
    320 function cache_taxonomie_ecrire($cache, $service, $tsn, $spip_langue='', $action='') {
     350 *        Toujours à vrai.
     351 */
     352function cache_taxonomie_ecrire($cache, $service, $tsn, $spip_langue = '', $action = '') {
    321353        // Création du dossier cache si besoin
    322354        sous_repertoire(_DIR_VAR, trim(_TAXONOMIE_CACHE_NOMDIR, '/'));
     
    336368 * @package SPIP\TAXONOMIE\CACHE
    337369 *
    338  * @param string    $service
    339  * @param int       $tsn
    340  * @param string    $spip_langue
    341  * @param string    $action
     370 * @param string $service
     371 * @param int    $tsn
     372 * @param string $spip_langue
     373 * @param string $action
    342374 *
    343375 * @return string
    344376 */
    345 function cache_taxonomie_nommer($service, $tsn, $spip_langue='', $action='') {
     377function cache_taxonomie_nommer($service, $tsn, $spip_langue = '', $action = '') {
    346378        // Construction du chemin complet d'un fichier cache
    347379        $fichier_cache = _TAXONOMIE_CACHE_DIR
    348                 . $service
    349                 . ($action ? '_' . $action : '')
    350                 . '_' . $tsn
    351                 . ($spip_langue ? '_' . $spip_langue : '')
    352                 . '.txt';
     380                                         . $service
     381                                         . ($action ? '_' . $action : '')
     382                                         . '_' . $tsn
     383                                         . ($spip_langue ? '_' . $spip_langue : '')
     384                                         . '.txt';
    353385
    354386        return $fichier_cache;
     
    361393 * @package SPIP\TAXONOMIE\CACHE
    362394 *
    363  * @param string    $service
    364  * @param int       $tsn
    365  * @param string    $spip_langue
    366  * @param string    $action
     395 * @param string $service
     396 * @param int    $tsn
     397 * @param string $spip_langue
     398 * @param string $action
    367399 *
    368400 * @return string
    369  *              Chemin du fichier cache si il existe ou chaine vide sinon.
    370  */
    371 function cache_taxonomie_existe($service, $tsn, $spip_langue='', $action='') {
     401 *        Chemin du fichier cache si il existe ou chaine vide sinon.
     402 */
     403function cache_taxonomie_existe($service, $tsn, $spip_langue = '', $action = '') {
    372404        // Contruire le nom du fichier cache
    373405        $fichier_cache = cache_taxonomie_nommer($service, $tsn, $spip_langue, $action);
     
    376408        // - chaine vide si le fichier n'existe pas
    377409        // - chemin complet du fichier si il existe
    378         if (!file_exists($fichier_cache))
     410        if (!file_exists($fichier_cache)) {
    379411                $fichier_cache = '';
     412        }
    380413
    381414        return $fichier_cache;
     
    388421 * @package SPIP\TAXONOMIE\CACHE
    389422 *
    390  * @param array|string  $caches
    391  *              Liste des fichiers à supprimer ou vide si tous les fichiers cache doivent être supprimés.
    392  *              Il est possible de passer un seul fichier comme une chaine.
     423 * @param array|string $caches
     424 *        Liste des fichiers à supprimer ou vide si tous les fichiers cache doivent être supprimés.
     425 *        Il est possible de passer un seul fichier comme une chaine.
    393426 *
    394427 * @return boolean
    395  *              Toujours à `true`.
    396  */
    397 function cache_taxonomie_supprimer($caches=array()){
     428 *        Toujours à `true`.
     429 */
     430function cache_taxonomie_supprimer($caches = array()) {
    398431        include_spip('inc/flock');
    399432
     
    401434                $fichiers_cache = is_string($caches) ? array($caches) : $caches;
    402435        } else {
    403                 $fichiers_cache = glob(_TAXONOMIE_CACHE_DIR . "*.*");
     436                $fichiers_cache = glob(_TAXONOMIE_CACHE_DIR . '*.*');
    404437        }
    405438
     
    412445        return true;
    413446}
    414 
    415 ?>
  • _plugins_/taxonomie/trunk/services/itis/itis_api.php

    r93059 r96992  
    44 *
    55 * @package SPIP\TAXONOMIE\SERVICES\ITIS
    6  * @todo phpdoc : exemples
    7  */
    8 
    9 if (!defined("_ECRIRE_INC_VERSION")) return;
    10 
    11 if (!defined('_TAXONOMIE_ITIS_ENDPOINT_BASE_URL'))
     6 * @todo    phpdoc : exemples
     7 */
     8if (!defined('_ECRIRE_INC_VERSION')) {
     9        return;
     10}
     11
     12if (!defined('_TAXONOMIE_ITIS_ENDPOINT_BASE_URL')) {
    1213        /**
    1314         * Préfixe des URL du service web de ITIS.
    1415         */
    1516        define('_TAXONOMIE_ITIS_ENDPOINT_BASE_URL', 'http://www.itis.gov/ITISWebService/');
    16 
    17 if (!defined('_TAXONOMIE_ITIS_TAXON_BASE_URL'))
     17}
     18
     19if (!defined('_TAXONOMIE_ITIS_TAXON_BASE_URL')) {
    1820        /**
    1921         * URL de base d'une page d'un taxon sur le site d'ITIS.
     
    2123         */
    2224        define('_TAXONOMIE_ITIS_TAXON_BASE_URL', 'http://www.itis.gov/servlet/SingleRpt/SingleRpt?search_topic=TSN&search_value=');
    23 
    24 if (!defined('_TAXONOMIE_ITIS_SITE_URL'))
     25}
     26
     27if (!defined('_TAXONOMIE_ITIS_SITE_URL')) {
    2528        /**
    2629         * URL de la page d'accueil du site ITIS.
     
    2831         */
    2932        define('_TAXONOMIE_ITIS_SITE_URL', 'http://www.itis.gov');
    30 
    31 if (!defined('_TAXONOMIE_ITIS_REGEXP_RANKNAME'))
     33}
     34
     35if (!defined('_TAXONOMIE_ITIS_REGEXP_RANKNAME')) {
    3236        /**
    3337         * Ligne d'un fichier ITIS hiérachie généré.
     
    3640         */
    3741        define('_TAXONOMIE_ITIS_REGEXP_RANKNAME', '#(%groups_list%):\s*(\w+)\s*\[([^\]]*)\]\s*\[(\d+)\]#');
     42}
    3843
    3944
     
    4348         * et code de langue SPIP. La langue du service est l'index, le code SPIP est la valeur.
    4449         */
    45         'french' => 'fr',
     50        'french'  => 'fr',
    4651        'english' => 'en',
    4752        'spanish' => 'es'
     
    5156         * Variable globale de configuration de l'api des actions du service web ITIS
    5257         */
    53         'search' => array(
    54                 'commonname' => array(
    55                         'function'      => 'searchByCommonName',
    56                         'argument'      => 'srchKey',
    57                         'list'          => 'commonNames',
    58                         'index'         => array('tsn' => 'tsn'),
    59                         'find'          => array('nom_commun' => 'commonName')
    60                 ),
    61                 'scientificname'=> array(
    62                         'function'  => 'searchByScientificName',
    63                         'argument'  => 'srchKey',
    64                         'list'      => 'scientificNames',
    65                         'index'         => array('tsn' => 'tsn'),
    66                         'find'      => array('nom_scientifique' => 'combinedName')
     58        'search'     => array(
     59                'commonname'     => array(
     60                        'function' => 'searchByCommonName',
     61                        'argument' => 'srchKey',
     62                        'list'     => 'commonNames',
     63                        'index'    => array('tsn' => 'tsn'),
     64                        'find'     => array('nom_commun' => 'commonName')
     65                ),
     66                'scientificname' => array(
     67                        'function' => 'searchByScientificName',
     68                        'argument' => 'srchKey',
     69                        'list'     => 'scientificNames',
     70                        'index'    => array('tsn' => 'tsn'),
     71                        'find'     => array('nom_scientifique' => 'combinedName')
    6772                )
    6873        ),
    6974        'vernacular' => array(
    7075                'vernacularlanguage' => array(
    71                         'function'  => 'getTsnByVernacularLanguage',
    72                         'argument'  => 'language',
    73                         'list'      => 'vernacularTsns',
    74                         'index'     => array('tsn' => 'commonName')
     76                        'function' => 'getTsnByVernacularLanguage',
     77                        'argument' => 'language',
     78                        'list'     => 'vernacularTsns',
     79                        'index'    => array('tsn' => 'commonName')
    7580                )
    7681        ),
    77         'getfull' => array(
     82        'getfull'    => array(
    7883                'record' => array(
    79                         'function'  => 'getFullRecordFromTSN',
    80                         'argument'  => 'tsn',
    81                         'list'      => '',
    82                         'index'     => array(
    83                                                         'nom_scientifique' => 'scientificName/combinedName',
    84                                                         'rang'              => 'taxRank/rankName',
    85                                                         'regne'             => 'kingdom/kingdomName',
    86                                                         'tsn_parent'        => 'parentTSN/parentTsn',
    87                                                         'auteur'            => 'taxonAuthor/authorship',
    88                                                         'nom_commun'        => 'commonNameList/commonNames',
     84                        'function' => 'getFullRecordFromTSN',
     85                        'argument' => 'tsn',
     86                        'list'     => '',
     87                        'index'    => array(
     88                                'nom_scientifique' => 'scientificName/combinedName',
     89                                'rang'             => 'taxRank/rankName',
     90                                'regne'            => 'kingdom/kingdomName',
     91                                'tsn_parent'       => 'parentTSN/parentTsn',
     92                                'auteur'           => 'taxonAuthor/authorship',
     93                                'nom_commun'       => 'commonNameList/commonNames',
    8994                        )
    9095                )
    9196        ),
    92         'get' => array(
     97        'get'        => array(
    9398                'scientificname' => array(
    94                         'function'  => 'getScientificNameFromTSN',
    95                         'argument'  => 'tsn',
    96                         'list'      => '',
    97                         'index'     => array('string', 'combinedName'),
    98                 ),
    99                 'kingdomname' => array(
     99                        'function' => 'getScientificNameFromTSN',
     100                        'argument' => 'tsn',
     101                        'list'     => '',
     102                        'index'    => array('string', 'combinedName'),
     103                ),
     104                'kingdomname'    => array(
    100105                        'function' => 'getKingdomNameFromTSN',
    101106                        'argument' => 'tsn',
    102                         'list'      => '',
    103                         'index'     => array('string', 'kingdomName'),
    104                 ),
    105                 'parent' => array(
     107                        'list'     => '',
     108                        'index'    => array('string', 'kingdomName'),
     109                ),
     110                'parent'         => array(
    106111                        'function' => 'getHierarchyUpFromTSN',
    107112                        'argument' => 'tsn',
    108                         'list'      => '',
    109                         'index'     => array('string', 'parentTsn'),
    110                 ),
    111                 'rankname' => array(
     113                        'list'     => '',
     114                        'index'    => array('string', 'parentTsn'),
     115                ),
     116                'rankname'       => array(
    112117                        'function' => 'getTaxonomicRankNameFromTSN',
    113118                        'argument' => 'tsn',
    114                         'list'      => '',
    115                         'index'     => array('string', 'rankName'),
    116                 ),
    117                 'author' => array(
     119                        'list'     => '',
     120                        'index'    => array('string', 'rankName'),
     121                ),
     122                'author'         => array(
    118123                        'function' => 'getTaxonAuthorshipFromTSN',
    119124                        'argument' => 'tsn',
    120                         'list'      => '',
    121                         'index'     => array('string', 'authorship'),
    122                 ),
    123                 'coremetadata' => array(
     125                        'list'     => '',
     126                        'index'    => array('string', 'authorship'),
     127                ),
     128                'coremetadata'   => array(
    124129                        'function' => 'getCoreMetadataFromTSN',
    125130                        'argument' => 'tsn',
    126                         'list'      => '',
    127                         'index'     => array('array', ''),
    128                 ),
    129                 'experts' => array(
     131                        'list'     => '',
     132                        'index'    => array('array', ''),
     133                ),
     134                'experts'        => array(
    130135                        'function' => 'getExpertsFromTSN',
    131136                        'argument' => 'tsn',
    132                         'list' => 'experts',
    133                         'index'     => array('array', ''),
    134                 ),
    135                 'commonnames' => array(
     137                        'list'     => 'experts',
     138                        'index'    => array('array', ''),
     139                ),
     140                'commonnames'    => array(
    136141                        'function' => 'getCommonNamesFromTSN',
    137142                        'argument' => 'tsn',
    138                         'list' => 'commonNames',
    139                         'index'     => array('array', array('language' => 'commonName')),
    140                 ),
    141                 'othersources' => array(
     143                        'list'     => 'commonNames',
     144                        'index'    => array('array', array('language' => 'commonName')),
     145                ),
     146                'othersources'   => array(
    142147                        'function' => 'getOtherSourcesFromTSN',
    143148                        'argument' => 'tsn',
    144                         'list' => 'otherSources',
    145                         'index'     => array('array', ''),
    146                 ),
    147                 'hierarchyfull' => array(
     149                        'list'     => 'otherSources',
     150                        'index'    => array('array', ''),
     151                ),
     152                'hierarchyfull'  => array(
    148153                        'function' => 'getFullHierarchyFromTSN',
    149154                        'argument' => 'tsn',
    150                         'list' => 'hierarchyList',
    151                         'index'     => array('array', ''),
    152                 ),
    153                 'hierarchydown' => array(
     155                        'list'     => 'hierarchyList',
     156                        'index'    => array('array', ''),
     157                ),
     158                'hierarchydown'  => array(
    154159                        'function' => 'getHierarchyDownFromTSN',
    155160                        'argument' => 'tsn',
    156                         'list' => 'hierarchyList',
    157                         'index'     => array('array', ''),
     161                        'list'     => 'hierarchyList',
     162                        'index'    => array('array', ''),
    158163                ),
    159164        ),
     
    175180 * @uses service_requeter_json()
    176181 *
    177  * @param string        $action
    178  *              Recherche par nom commun ou par nom scientifique. Prend les valeurs `commonname` ou `scientificname`
    179  * @param string        $search
    180  *              Nom à rechercher précisément. Seul le taxon dont le nom coincidera exactement sera retourné.
    181  * @param bool          $strict
    182  *              `true` indique une correspondance stricte de la chaine recherchée ce qui a pour conséquence de renvoyer
    183  *              une seule valeur de TSN. `false` indique une correspondance partielle et peut donc renvoyer plusieurs TSN.
     182 * @param string $action
     183 *        Recherche par nom commun ou par nom scientifique. Prend les valeurs `commonname` ou `scientificname`
     184 * @param string $search
     185 *        Nom à rechercher précisément. Seul le taxon dont le nom coincidera exactement sera retourné.
     186 * @param bool   $strict
     187 *        `true` indique une correspondance stricte de la chaine recherchée ce qui a pour conséquence de renvoyer
     188 *        une seule valeur de TSN. `false` indique une correspondance partielle et peut donc renvoyer plusieurs TSN.
    184189 *
    185190 * @return array
    186  *              Si la recherche est stricte, la fonction retourne l'identifiant unique TSN dans la base ITIS
    187  *              ou 0 si la recherche échoue.
    188  *              Sinon, la fonction retourne une liste de couples de valeurs (TNS, valeur trouvée).
    189  */
    190 function itis_search_tsn($action, $search, $strict=true) {
     191 *        Si la recherche est stricte, la fonction retourne l'identifiant unique TSN dans la base ITIS
     192 *        ou 0 si la recherche échoue.
     193 *        Sinon, la fonction retourne une liste de couples de valeurs (TNS, valeur trouvée).
     194 */
     195function itis_search_tsn($action, $search, $strict = true) {
    191196        global $itis_webservice;
    192197        $tsn = array();
     
    212217                        if ($_data) {
    213218                                if (!$strict
    214                                 OR ($strict AND (strcasecmp($_data[$search_key], $search) == 0))) {
     219                                        or ($strict and (strcasecmp($_data[$search_key], $search) == 0))
     220                                ) {
    215221                                        $tsn[] = array(
    216                                                 $tsn_destination => intval($_data[$tsn_key]),
    217                                                 $search_destination => $_data[$search_key]);
    218                                         if ($strict) {break;}
     222                                                $tsn_destination    => intval($_data[$tsn_key]),
     223                                                $search_destination => $_data[$search_key]
     224                                        );
     225                                        if ($strict) {
     226                                                break;
     227                                        }
    219228                                }
    220229                        }
     
    233242 * @uses service_requeter_json()
    234243 *
    235  * @param int   $tsn
    236  *              Identifiant unique du taxon dans la base ITIS, le TSN
     244 * @param int $tsn
     245 *        Identifiant unique du taxon dans la base ITIS, le TSN
    237246 *
    238247 * @return array
    239  *              Si le taxon est trouvé, le tableau renvoyé possède les index associatifs suivants:
    240  *              - `nom_scientique`      : le nom scientifique du taxon en minuscules
    241  *              - `rang`                        : le nom anglais du rang taxonomique du taxon
    242  *              - `regne`                       : le nom scientifque du règne du taxon en minuscules
    243  *              - `tsn_parent`          : le TSN du parent du taxon ou 0 si le taxon est un règne
    244  *              - `auteur`                      : la citation d’auteurs et la date de publication
    245  *              - `nom_commun`          : un tableau indexé par langue (au sens d'ITIS en minuscules, `english`, `french`, `spanish`)
    246  *                                                       fournissant le nom commun dans chacune des langues
     248 *        Si le taxon est trouvé, le tableau renvoyé possède les index associatifs suivants:
     249 *        - `nom_scientique`    : le nom scientifique du taxon en minuscules
     250 *        - `rang`            : le nom anglais du rang taxonomique du taxon
     251 *        - `regne`            : le nom scientifque du règne du taxon en minuscules
     252 *        - `tsn_parent`        : le TSN du parent du taxon ou 0 si le taxon est un règne
     253 *        - `auteur`            : la citation d’auteurs et la date de publication
     254 *        - `nom_commun`        : un tableau indexé par langue (au sens d'ITIS en minuscules, `english`, `french`,
     255 *        `spanish`) fournissant le nom commun dans chacune des langues
    247256 */
    248257function itis_get_record($tsn) {
     
    272281        $noms = array();
    273282        if (is_array($record['nom_commun'])
    274         AND $record['nom_commun']) {
     283                and $record['nom_commun']
     284        ) {
    275285                foreach ($record['nom_commun'] as $_nom) {
    276286                        $noms[strtolower($_nom['language'])] = trim($_nom['commonName']);
     
    291301 * @uses service_requeter_json()
    292302 *
    293  * @param string        $action
    294  *              Type d'information demandé. Prend les valeurs
    295  *              - `scientificname`      : le nom scientifique du taxon
    296  *              - `kingdomname`         : le règne du taxon
    297  *              - `parent`                      : le taxon parent dont son TSN
    298  *              - `rankname`            : le rang taxonomique du taxon
    299  *              - `author`                      : le ou les auteurs du taxon
    300  *              - `coremetadata`        : les métadonnées (à vérifier)
    301  *              - `experts`                     : les experts du taxon
    302  *              - `commonnames`         : le ou les noms communs
    303  *              - `othersources`        : les sources d'information sur le taxon
    304  *              - `hierarchyfull`       : la hiérarchie complète jusqu'au taxon
    305  *              - `hierarchydown`       : la hiérarchie (à vérifier)
    306  * @param int           $tsn
    307  *              Identifiant unique du taxon dans la base ITIS (TSN)
     303 * @param string $action
     304 *        Type d'information demandé. Prend les valeurs
     305 *        - `scientificname`    : le nom scientifique du taxon
     306 *        - `kingdomname`        : le règne du taxon
     307 *        - `parent`            : le taxon parent dont son TSN
     308 *        - `rankname`        : le rang taxonomique du taxon
     309 *        - `author`            : le ou les auteurs du taxon
     310 *        - `coremetadata`    : les métadonnées (à vérifier)
     311 *        - `experts`            : les experts du taxon
     312 *        - `commonnames`        : le ou les noms communs
     313 *        - `othersources`    : les sources d'information sur le taxon
     314 *        - `hierarchyfull`    : la hiérarchie complète jusqu'au taxon
     315 *        - `hierarchydown`    : la hiérarchie (à vérifier)
     316 * @param int    $tsn
     317 *        Identifiant unique du taxon dans la base ITIS (TSN)
    308318 *
    309319 * @return string|array
    310  *              Chaine ou tableau caractéristique du type d'information demandé.
     320 *        Chaine ou tableau caractéristique du type d'information demandé.
    311321 */
    312322function itis_get_information($action, $tsn) {
     
    369379 *
    370380 * @param $language
    371  *              Langue au sens d'ITIS écrite en minuscules. Vaut `french`, `english`, `spanish`...
     381 *        Langue au sens d'ITIS écrite en minuscules. Vaut `french`, `english`, `spanish`...
    372382 *
    373383 * @return array
    374  *              Tableau des noms communs associés à leur TSN. Le format du tableau est le suivant:
    375  *              - l'index représente le TSN du taxon,
    376  *              - la valeur fournit le tableau des noms communs, chaque nom étant préfixé du code de langue
    377  *              de SPIP (ex: `[fr]bactéries`)
     384 *        Tableau des noms communs associés à leur TSN. Le format du tableau est le suivant:
     385 *        - l'index représente le TSN du taxon,
     386 *        - la valeur fournit le tableau des noms communs, chaque nom étant préfixé du code de langue
     387 *        de SPIP (ex: `[fr]bactéries`)
    378388 */
    379389function itis_list_vernaculars($language) {
    380390        global $itis_webservice, $itis_language;
    381         $vernaculars =array();
     391        $vernaculars = array();
    382392
    383393        // Construire l'URL de l'api sollicitée
     
    387397        include_spip('inc/taxonomer');
    388398        include_spip('inc/distant');
    389         $data = service_requeter_json($url, _INC_DISTANT_MAX_SIZE*7);
     399        $data = service_requeter_json($url, _INC_DISTANT_MAX_SIZE * 7);
    390400
    391401        $api = $itis_webservice['vernacular']['vernacularlanguage'];
     
    395405                foreach ($data[$api['list']] as $_data) {
    396406                        if (!empty($_data[$destination])
    397                         AND !empty($_data[$name_key])) {
     407                                and !empty($_data[$name_key])
     408                        ) {
    398409                                $vernaculars[$_data[$destination]][] = $tag_language . $_data[$name_key];
    399410                        }
     
    414425 * @api
    415426 *
    416  * @param string        $kingdom
    417  *              Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
    418  * @param string        $upto
    419  *              Rang taxonomique minimal jusqu'où charger le règne. Ce rang est fourni en anglais et en minuscules.
    420  *              Il prend les valeurs :
    421  *              - `phylum` (pour le règne Animalia) ou `division` (pour les règnes Fungi et Plantae),
    422  *              - `class`,
    423  *              - `order`,
    424  *              - `family`,
    425  *              - `genus`.
    426  * @param int           $sha_file
    427  *              Sha calculé à partir du fichier de taxons correspondant au règne choisi. Le sha est retourné
    428  *              par la fonction afin d'être stocké par le plugin.
     427 * @param string $kingdom
     428 *        Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
     429 * @param string $upto
     430 *        Rang taxonomique minimal jusqu'où charger le règne. Ce rang est fourni en anglais et en minuscules.
     431 *        Il prend les valeurs :
     432 *        - `phylum` (pour le règne Animalia) ou `division` (pour les règnes Fungi et Plantae),
     433 *        - `class`,
     434 *        - `order`,
     435 *        - `family`,
     436 *        - `genus`.
     437 * @param int    $sha_file
     438 *        Sha calculé à partir du fichier de taxons correspondant au règne choisi. Le sha est retourné
     439 *        par la fonction afin d'être stocké par le plugin.
    429440 *
    430441 * @return array
    431  *              Chaque élément du tableau est un taxon. Un taxon est un tableau associatif dont chaque
    432  *              index correspond à un champ de la table `spip_taxons`. Le tableau est ainsi prêt pour une
    433  *              insertion en base de données.
     442 *        Chaque élément du tableau est un taxon. Un taxon est un tableau associatif dont chaque
     443 *        index correspond à un champ de la table `spip_taxons`. Le tableau est ainsi prêt pour une
     444 *        insertion en base de données.
    434445 */
    435446function itis_read_hierarchy($kingdom, $upto, &$sha_file) {
     
    440451        static $group_ids = array(
    441452                'kingdom' => 1,
    442                 'class' => 3,
    443                 'order' => 4,
    444                 'family' => 5,
    445                 'genus' => 6,
    446                 'specie' => 7);
    447         $rang_phylum = $kingdom==_TAXONOMIE_REGNE_ANIMAL ? 'phylum': 'division';
     453                'class'   => 3,
     454                'order'   => 4,
     455                'family'  => 5,
     456                'genus'   => 6,
     457                'specie'  => 7
     458        );
     459        $rang_phylum = $kingdom == _TAXONOMIE_REGNE_ANIMAL ? 'phylum' : 'division';
    448460        $group_ids[$rang_phylum] = 2;
    449461        asort($group_ids);
     
    457469                $file = find_in_path('services/itis/' . ucfirst($kingdom) . '_Genus.txt');
    458470                if (file_exists($file)
    459                 AND ($sha_file = sha1_file($file))) {
     471                        and ($sha_file = sha1_file($file))
     472                ) {
    460473                        $lines = file($file);
    461474                        if ($lines) {
    462475                                $groups = array();
    463                                 for ($i=1;$i<=array_search($upto, $group_ids);$i++) {
     476                                for ($i = 1; $i <= array_search($upto, $group_ids); $i++) {
    464477                                        $groups[$i] = 0;
    465478                                }
     
    467480                                foreach ($lines as $_line) {
    468481                                        $taxon = array(
    469                                                 'regne' => $kingdom,
     482                                                'regne'      => $kingdom,
    470483                                                'nom_commun' => '',
    471484                                                'descriptif' => '',
    472                                                 'edite' => 'non');
     485                                                'edite'      => 'non'
     486                                        );
    473487                                        if (preg_match($regexp, $_line, $match)) {
    474488                                                // Initialisation du taxon
     
    484498                                                        // On traite à part le cas du règne qui ne se rencontre qu'une fois en début de fichier
    485499                                                        $taxon['tsn_parent'] = 0;
    486                                                 }
    487                                                 else {
    488                                                         for($i=$taxon_group_id-1;$i>=1;$i--) {
     500                                                } else {
     501                                                        for ($i = $taxon_group_id - 1; $i >= 1; $i--) {
    489502                                                                if ($groups[$i]) {
    490503                                                                        $taxon['tsn_parent'] = $groups[$i];
     
    500513                                                $groups[$taxon_group_id] = $tsn;
    501514                                                // On vide les groupes d'après
    502                                                 for($i=$taxon_group_id+1;$i<=5;$i++) {
     515                                                for ($i = $taxon_group_id + 1; $i <= 5; $i++) {
    503516                                                        $groups[$i] = 0;
    504517                                                }
     
    516529 * Lit le fichier des noms communs - tout règne confondu - d'une langue donnée et renvoie un tableau
    517530 * de tous ces noms indexés par leur TSN.
    518  *
    519  * @api
    520  *
    521  * @param string        $language
    522  *              Langue au sens d'ITIS écrite en minuscules. Vaut `french`, `english`, `spanish` etc.
    523  * @param int           $sha_file
    524  *              Sha calculé à partir du fichier des noms communs choisi. Le sha est retourné
    525  *              par la fonction afin d'être stocké par le plugin.
     531 * La base de données ITIS contient souvent plusieurs traductions d'une même langue pour un taxon donné. Cette
     532 * fonction met à jour séquentiellement les traductions sans s'en préoccuper. De fait, c'est la dernière traduction
     533 * rencontrée qui sera fournie dans le tableau de sortie.
     534 *
     535 * @api
     536 *
     537 * @param string $language
     538 *        Langue au sens d'ITIS écrite en minuscules. Vaut `french`, `english`, `spanish` etc.
     539 * @param int    $sha_file
     540 *        Sha calculé à partir du fichier des noms communs choisi. Le sha est retourné
     541 *        par la fonction afin d'être stocké par le plugin.
    526542 *
    527543 * @return array
    528  *              Tableau des noms communs d'une langue donnée indexé par TSN. Le nom commun est préfixé
    529  *              par le tag de langue SPIP pour être utilisé simplement dans une balise `<multi>`.
     544 *        Tableau des noms communs d'une langue donnée indexé par TSN. Le nom commun est préfixé
     545 *        par le tag de langue SPIP pour être utilisé simplement dans une balise `<multi>`.
    530546 */
    531547function itis_read_vernaculars($language, &$sha_file) {
    532548        global $itis_language;
    533         $vernaculars =array();
     549        $vernaculars = array();
    534550        $sha_file = false;
    535551
     
    537553        $file = find_in_path("services/itis/vernaculars_${language}.csv");
    538554        if (file_exists($file)
    539         AND ($sha_file = sha1_file($file))) {
     555                and ($sha_file = sha1_file($file))
     556        ) {
    540557                // Lecture du fichier csv comme un fichier texte sachant que :
    541558                // - le délimiteur de colonne est une virgule
     
    566583 * @api
    567584 *
    568  * @param string    $spip_language
    569  *      Code de langue de SPIP. Prend les valeurs `fr`, `en`, `es`, etc.
    570  *              La variable globale `$itis_language` définit le transcodage langue ITIS vers code SPIP.
     585 * @param string $spip_language
     586 *        Code de langue de SPIP. Prend les valeurs `fr`, `en`, `es`, etc.
     587 *        La variable globale `$itis_language` définit le transcodage langue ITIS vers code SPIP.
    571588 *
    572589 * @return string
     
    576593        global $itis_language;
    577594
    578         if (!$language = array_search($spip_language,  $itis_language)) {
     595        if (!$language = array_search($spip_language, $itis_language)) {
    579596                $language = '';
    580597        }
     
    590607 * @api
    591608 *
    592  * @param int   $id_taxon
    593  *              Id du taxon nécessaire pour construire l'url de la page ITIS fournissant une information complète sur
    594  *              le taxon.
    595  * @param array $informations
    596  *              Tableau des informations complémentaires sur la source. Pour ITIS ce tableau est vide.
     609 * @param int   $id_taxon
     610 *        Id du taxon nécessaire pour construire l'url de la page ITIS fournissant une information complète sur
     611 *        le taxon.
     612 * @param array $informations
     613 *        Tableau des informations complémentaires sur la source. Pour ITIS ce tableau est vide.
    597614 *
    598615 * @return string
    599  *              Phrase de crédit.
    600  */
    601 function itis_credit($id_taxon, $informations) {
     616 *        Phrase de crédit.
     617 */
     618function itis_credit($id_taxon, $informations = array()) {
    602619        // On recherche le TSN du taxon afin de construire l'url vers sa page sur ITIS
    603         $taxon = sql_fetsel('tsn, nom_scientifique', 'spip_taxons', 'id_taxon='. sql_quote($id_taxon));
     620        $taxon = sql_fetsel('tsn, nom_scientifique', 'spip_taxons', 'id_taxon=' . sql_quote($id_taxon));
    604621
    605622        // On crée l'url du taxon sur le site ITIS
     
    609626
    610627        // On établit la citation
    611         $credit = _T('taxonomie:credit_itis', array('url_site' => $link_site, 'url_taxon' => $link_taxon));
     628        $credit = _T('taxonomie:credit_itis', array_merge(array('url_site' => $link_site, 'url_taxon' => $link_taxon), $informations));
    612629
    613630        return $credit;
     
    622639 *
    623640 * @return array
    624  *      Tableau à deux index principaux:
    625  *              - `taxons`              : tableau associatif indexé par règne
    626  *              - `traductions` : tableau associatif par code de langue SPIP
     641 *    Tableau à deux index principaux:
     642 *        - `taxons`        : tableau associatif indexé par règne
     643 *        - `traductions`    : tableau associatif par code de langue SPIP
    627644 */
    628645function itis_review_sha() {
     
    636653                $file = find_in_path('services/itis/' . ucfirst($_kingdom) . '_Genus.txt');
    637654                if (file_exists($file)
    638                 AND ($sha_file = sha1_file($file))) {
     655                        and ($sha_file = sha1_file($file))
     656                ) {
    639657                        $shas['taxons'][$_kingdom] = $sha_file;
    640658                }
     
    644662                $file = find_in_path("services/itis/vernaculars_${_language}.csv");
    645663                if (file_exists($file)
    646                 AND ($sha_file = sha1_file($file))) {
     664                        and ($sha_file = sha1_file($file))
     665                ) {
    647666                        $shas['traductions'][$itis_language[$_language]] = $sha_file;
    648667                }
     
    660679 * Construit l'URL de la requête ITIS correspondant à la demande utilisateur.
    661680 *
    662  * @param string        $format
    663  *              Format du résultat de la requête. Prend les valeurs `json` ou `xml`. Le `json` est recommandé.
    664  * @param string        $group
    665  *              Groupe d'actions du même type. Prend les valeurs:
    666  *              - `search`              : groupe des actions de recherche du TSN à partir du nom commun ou scientifique
    667  *              - `vernacular`  : groupe de l'action fournissant les noms communs d'une langue donnée
    668  *              - `getfull`             : groupe de l'action fournissant l'ensemble des informations d'un taxon
    669  *              - `get`                 : groupe des actions fournissant une information précise sur un taxon
    670  * @param string        $action
    671  *              Nom de l'action du service ITIS. Les valeurs dépendent du groupe. Par exemple, pour le groupe
    672  *              `search` les actions sont `commonname` et `scientificname`.
    673  * @param string        $key
    674  *              Clé de recherche qui dépend de l'action demandée. Ce peut être le nom scientifique, le TSN, etc.
    675  *              Cette clé doit être encodée si besoin par l'appelant.
     681 * @param string $format
     682 *        Format du résultat de la requête. Prend les valeurs `json` ou `xml`. Le `json` est recommandé.
     683 * @param string $group
     684 *        Groupe d'actions du même type. Prend les valeurs:
     685 *        - `search`        : groupe des actions de recherche du TSN à partir du nom commun ou scientifique
     686 *        - `vernacular`    : groupe de l'action fournissant les noms communs d'une langue donnée
     687 *        - `getfull`        : groupe de l'action fournissant l'ensemble des informations d'un taxon
     688 *        - `get`            : groupe des actions fournissant une information précise sur un taxon
     689 * @param string $action
     690 *        Nom de l'action du service ITIS. Les valeurs dépendent du groupe. Par exemple, pour le groupe
     691 *        `search` les actions sont `commonname` et `scientificname`.
     692 * @param string $key
     693 *        Clé de recherche qui dépend de l'action demandée. Ce peut être le nom scientifique, le TSN, etc.
     694 *        Cette clé doit être encodée si besoin par l'appelant.
    676695 *
    677696 * @return string
    678  *              L'URL de la requête au service
     697 *        L'URL de la requête au service
    679698 */
    680699function api2url_itis($format, $group, $action, $key) {
     
    683702        // Construire l'URL de l'api sollicitée
    684703        $url = _TAXONOMIE_ITIS_ENDPOINT_BASE_URL
    685                  . ($format=='json' ? 'jsonservice/' : 'services/ITISService/')
    686                  . $itis_webservice[$group][$action]['function'] . '?'
    687                  . $itis_webservice[$group][$action]['argument'] . '=' . $key;
     704                   . ($format == 'json' ? 'jsonservice/' : 'services/ITISService/')
     705                   . $itis_webservice[$group][$action]['function'] . '?'
     706                   . $itis_webservice[$group][$action]['argument'] . '=' . $key;
    688707
    689708        return $url;
    690709}
    691 ?>
  • _plugins_/taxonomie/trunk/services/wikipedia/wikipedia_api.php

    r93059 r96992  
    44 *
    55 * @package SPIP\TAXONOMIE\SERVICES\WIKIPEDIA
    6  * @todo phpdoc : exemples
    7  */
    8 
    9 if (!defined("_ECRIRE_INC_VERSION")) return;
    10 
    11 if (!defined('_TAXONOMIE_WIKIPEDIA_ENDPOINT_BASE_URL'))
     6 * @todo    phpdoc : exemples
     7 */
     8if (!defined('_ECRIRE_INC_VERSION')) {
     9        return;
     10}
     11
     12if (!defined('_TAXONOMIE_WIKIPEDIA_ENDPOINT_BASE_URL')) {
    1213        /**
    1314         * Préfixe des URL du service web de WIKIPEDIA.
    1415         */
    1516        define('_TAXONOMIE_WIKIPEDIA_ENDPOINT_BASE_URL', 'http://%langue%.wikipedia.org/w/api.php');
    16 
    17 if (!defined('_TAXONOMIE_WIKIPEDIA_PAGE_BASE_URL'))
     17}
     18
     19if (!defined('_TAXONOMIE_WIKIPEDIA_PAGE_BASE_URL')) {
    1820        /**
    1921         * URL de base pour construire une page de Wikipedia dans une langue donnée
    2022         */
    2123        define('_TAXONOMIE_WIKIPEDIA_PAGE_BASE_URL', 'https://%langue%.wikipedia.org/wiki/');
    22 
    23 if (!defined('_TAXONOMIE_WIKIPEDIA_CACHE_TIMEOUT'))
     24}
     25
     26if (!defined('_TAXONOMIE_WIKIPEDIA_CACHE_TIMEOUT')) {
    2427        /**
    2528         * Période de renouvellement du cache de Wikipedia (30 jours)
    2629         */
    27         define('_TAXONOMIE_WIKIPEDIA_CACHE_TIMEOUT', 86400*30);
     30        define('_TAXONOMIE_WIKIPEDIA_CACHE_TIMEOUT', 86400 * 30);
     31}
    2832
    2933$GLOBALS['wikipedia_language'] = array(
     
    5559 * @uses service_requeter_json()
    5660 *
    57  * @param int           $tsn
    58  *              Identifiant ITIS du taxon, le TSN. Etant donné que ce service s'utilise toujours sur un taxon
    59  *              existant le TSN existe toujours. Il sert à créer le fichier cache.
    60  * @param string        $search
    61  *              Chaine de recherche qui est en généralement le nom scientifique du taxon.
    62  * @param string        $language
    63  *              Langue au sens de Wikipedia qui préfixe l'url du endpoint. Vaut `fr`, `en`, `es`...
    64  * @param int|null      $section
    65  *              Section de page dont le texte est à renvoyer. Entier supérieur ou égal à 0 ou `null` pour tout la page.
    66  *              Cet argument est optionnel.
    67  *
    68  * @return string
    69  *              Texte trouvé rédigé en mediawiki ou chaine vide sinon. Pour traduire le texte en SPIP
    70  *              il est nécessaire d'utiliser le plugin Convertisseur. Néanmoins, le texte même traduit
    71  *              doit être remanié manuellement.
    72  */
    73 function wikipedia_get($tsn, $search, $language, $section=null) {
     61 * @param int      $tsn
     62 *        Identifiant ITIS du taxon, le TSN. Etant donné que ce service s'utilise toujours sur un taxon
     63 *        existant le TSN existe toujours. Il sert à créer le fichier cache.
     64 * @param string   $search
     65 *        Chaine de recherche qui est en généralement le nom scientifique du taxon.
     66 * @param string   $language
     67 *        Langue au sens de Wikipedia qui préfixe l'url du endpoint. Vaut `fr`, `en`, `es`...
     68 * @param int|null $section
     69 *        Section de page dont le texte est à renvoyer. Entier supérieur ou égal à 0 ou `null` pour tout la page.
     70 *        Cet argument est optionnel.
     71 *
     72 * @return string
     73 *        Texte trouvé rédigé en mediawiki ou chaine vide sinon. Pour traduire le texte en SPIP
     74 *        il est nécessaire d'utiliser le plugin Convertisseur. Néanmoins, le texte même traduit
     75 *        doit être remanié manuellement.
     76 */
     77function wikipedia_get($tsn, $search, $language, $section = null) {
    7478        $information = array();
    7579
     
    7882        include_spip('inc/taxonomer');
    7983        if (!$file_cache = cache_taxonomie_existe('wikipedia', $tsn, $language)
    80         OR !filemtime($file_cache)
    81         OR (time()-filemtime($file_cache)>_TAXONOMIE_WIKIPEDIA_CACHE_TIMEOUT)) {
     84                or !filemtime($file_cache)
     85                or (time() - filemtime($file_cache) > _TAXONOMIE_WIKIPEDIA_CACHE_TIMEOUT)
     86        ) {
    8287                // Normaliser la recherche: trim et mise en lettres minuscules
    8388                $search = strtolower(trim($search));
     
    9398                // Récupération de la section demandée.
    9499                if (isset($data['batchcomplete'])
    95                 AND isset($data['query']['pages'])) {
     100                        and isset($data['query']['pages'])
     101                ) {
    96102                        $reponses = $data['query']['pages'];
    97103                        $page = reset($reponses);
    98104                        $id = key($reponses);
    99105                        if (($id > 0)
    100                         AND !isset($page['missing'])
    101                         AND isset($page['revisions'][0]['*'])) {
     106                                and !isset($page['missing'])
     107                                        and isset($page['revisions'][0]['*'])
     108                        ) {
    102109                                $information['texte'] = $page['revisions'][0]['*'];
    103110                        }
     
    126133 * @api
    127134 *
    128  * @param string        $language_code
    129  *              Code de langue de SPIP. Prend les valeurs `fr`, `en`, `es`, etc.
    130  *              La variable globale `$wikipedia_language` définit le transcodage langue Wikipedia vers code SPIP.
    131  *
    132  * @return string
    133  *              Langue au sens de Wikipedia - `fr`, `en`, `es` - ou chaine vide sinon.
     135 * @param string $language_code
     136 *        Code de langue de SPIP. Prend les valeurs `fr`, `en`, `es`, etc.
     137 *        La variable globale `$wikipedia_language` définit le transcodage langue Wikipedia vers code SPIP.
     138 *
     139 * @return string
     140 *        Langue au sens de Wikipedia - `fr`, `en`, `es` - ou chaine vide sinon.
    134141 */
    135142function wikipedia_spipcode2language($language_code) {
    136143        global $wikipedia_language;
    137144
    138         if (!$language = array_search($language_code,  $wikipedia_language)) {
     145        if (!$language = array_search($language_code, $wikipedia_language)) {
    139146                $language = '';
    140147        }
     
    149156 * @api
    150157 *
    151  * @param int   $id_taxon
    152  *              Id du taxon nécessaire pour construire l'url de la page Wikipedia concernée.
    153  * @param array $informations
    154  *              Tableau des informations complémentaires sur la source. Pour Wikipedia ce tableau fourni le ou
    155  *              les champs remplis avec Wikipedia.
     158 * @param int   $id_taxon
     159 *        Id du taxon nécessaire pour construire l'url de la page Wikipedia concernée.
     160 * @param array $informations
     161 *        Tableau des informations complémentaires sur la source. Pour Wikipedia ce tableau fourni le ou
     162 *        les champs remplis avec Wikipedia.
    156163 *
    157164 * @return string
     
    160167function wikipedia_credit($id_taxon, $informations) {
    161168        // On recherche le tsn du taxon afin de construire l'url vers sa page sur ITIS
    162         $taxon = sql_fetsel('tsn, nom_scientifique', 'spip_taxons', 'id_taxon='. sql_quote($id_taxon));
     169        $taxon = sql_fetsel('tsn, nom_scientifique', 'spip_taxons', 'id_taxon=' . sql_quote($id_taxon));
    163170
    164171        // On crée l'url du taxon sur le site de Wikipedia
    165172        $url = str_replace('%langue%', 'fr', _TAXONOMIE_WIKIPEDIA_PAGE_BASE_URL)
    166                 . rawurlencode($taxon['nom_scientifique']);
     173                   . rawurlencode($taxon['nom_scientifique']);
    167174        $link = '<a href="' . $url . '"><em>' . ucfirst($taxon['nom_scientifique']) . '</em></a>';
    168175
     
    172179
    173180        // On établit la citation
    174         $credit = _T('taxonomie:credit_wikipedia', array('champs' => strtolower($champs),'url_taxon' => $link));
     181        $credit = _T('taxonomie:credit_wikipedia', array('champs' => strtolower($champs), 'url_taxon' => $link));
    175182
    176183        return $credit;
     
    185192 * Construit l'URL de la requête Wikipedia correspondant à la demande utilisateur.
    186193 *
    187  * @param string        $format
    188  *              Format du résultat de la requête. Prend les valeurs `json` ou `xml`. Le `json` est recommandé.
    189  * @param string        $action
    190  *              Nom de l'action du service Wikipedia. La seule action `query` est utilisée dans cette API.
    191  * @param string        $language
    192  *              Langue au sens de Wikipedia en minuscules. Prend les valeurs `fr`, `en`, `es`, etc.
    193  * @param string        $search
    194  *              Clé de recherche qui est essentiellement le nom scientifique dans l'utilisation normale.
    195  *              Cette clé doit être encodée si besoin par l'appelant.
    196  * @param int|null      $section
    197  *              Section de la page à renvoyer. Valeur entière de 0 à n ou null si on veut toute la page.
    198  *
    199  * @return string
    200  *              L'URL de la requête au service
     194 * @param string   $format
     195 *        Format du résultat de la requête. Prend les valeurs `json` ou `xml`. Le `json` est recommandé.
     196 * @param string   $action
     197 *        Nom de l'action du service Wikipedia. La seule action `query` est utilisée dans cette API.
     198 * @param string   $language
     199 *        Langue au sens de Wikipedia en minuscules. Prend les valeurs `fr`, `en`, `es`, etc.
     200 * @param string   $search
     201 *        Clé de recherche qui est essentiellement le nom scientifique dans l'utilisation normale.
     202 *        Cette clé doit être encodée si besoin par l'appelant.
     203 * @param int|null $section
     204 *        Section de la page à renvoyer. Valeur entière de 0 à n ou null si on veut toute la page.
     205 *
     206 * @return string
     207 *        L'URL de la requête au service
    201208 */
    202209function api2url_wikipedia($format, $action, $language, $search, $section) {
     
    204211        // Construire l'URL de l'api sollicitée
    205212        $url = str_replace('%langue%', $language, _TAXONOMIE_WIKIPEDIA_ENDPOINT_BASE_URL) . '?'
    206                 . 'action=' . $action
    207                 . '&meta=siteinfo|wikibase'
    208                 . '&prop=revisions&rvprop=content'
    209                 . (!is_null($section) ? '&rvsection=' . $section : '')
    210                 . '&continue=&redirects=1'
    211                 . '&format=' . $format
    212                 . '&titles=' . rawurlencode(ucfirst($search));
     213                   . 'action=' . $action
     214                   . '&meta=siteinfo|wikibase'
     215                   . '&prop=revisions&rvprop=content'
     216                   . (!is_null($section) ? '&rvsection=' . $section : '')
     217                   . '&continue=&redirects=1'
     218                   . '&format=' . $format
     219                   . '&titles=' . rawurlencode(ucfirst($search));
    213220
    214221        return $url;
    215222}
    216 
    217 ?>
  • _plugins_/taxonomie/trunk/taxonomie_fonctions.php

    r96990 r96992  
    55 * @package SPIP\TAXONOMIE\API
    66 */
    7 
    8 if (!defined("_ECRIRE_INC_VERSION")) return;
     7if (!defined('_ECRIRE_INC_VERSION')) {
     8        return;
     9}
     10
    911
    1012/**
     
    2325 * @uses itis_read_vernaculars()
    2426 *
    25  * @param string        $regne
    26  *              Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
    27  * @param string        $rang
    28  *              Rang taxonomique minimal jusqu'où charger le règne. Ce rang est fourni en anglais, en minuscules et
    29  *              correspond à : `phylum`, `class`, `order`, `family`, `genus`.
    30  * @param array         $codes_langue
    31  *              Tableau des codes (au sens SPIP) des langues à charger pour les noms communs des taxons.
     27 * @param string $regne
     28 *        Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
     29 * @param string $rang
     30 *        Rang taxonomique minimal jusqu'où charger le règne. Ce rang est fourni en anglais, en minuscules et
     31 *        correspond à : `phylum`, `class`, `order`, `family`, `genus`.
     32 * @param array  $codes_langue
     33 *        Tableau des codes (au sens SPIP) des langues à charger pour les noms communs des taxons.
    3234 *
    3335 * @return bool
    34  *              `true` si le chargement a réussi, `false` sinon
    35  */
    36 function taxonomie_charger_regne($regne, $rang, $codes_langue=array()) {
     36 *        `true` si le chargement a réussi, `false` sinon
     37 */
     38function taxonomie_charger_regne($regne, $rang, $codes_langue = array()) {
    3739        $retour = false;
    3840        $taxons_edites = array();
     
    8486                if ($traductions) {
    8587                        foreach ($traductions as $_tsn) {
    86                                 $taxons[$_tsn]['nom_commun'] =  '<multi>' . $taxons[$_tsn]['nom_commun'] . '</multi>';
     88                                $taxons[$_tsn]['nom_commun'] = '<multi>' . $taxons[$_tsn]['nom_commun'] . '</multi>';
    8789                        }
    8890                }
     
    9597                        foreach ($taxons_edites as $_taxon_edite) {
    9698                                if (($tsn = $_taxon_edite['tsn'])
    97                                 AND (array_key_exists($tsn, $taxons))) {
     99                                        and (array_key_exists($tsn, $taxons))
     100                                ) {
    98101                                        $taxons[$tsn]['descriptif'] = $_taxon_edite['descriptif'];
    99102                                        $taxons[$tsn]['nom_commun'] = taxon_merger_traductions(
    100                                                                                                         $_taxon_edite['nom_commun'],
    101                                                                                                         $taxons[$tsn]['nom_commun']);
     103                                                $_taxon_edite['nom_commun'],
     104                                                $taxons[$tsn]['nom_commun']);
    102105                                        $taxons[$tsn]['edite'] = 'oui';
    103106                                }
     
    129132 * @filtre
    130133 *
    131  * @param string        $regne
    132  *              Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
     134 * @param string $regne
     135 *        Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
    133136 *
    134137 * @return bool
    135  *              `true` si le vidage a réussi, `false` sinon
     138 *        `true` si le vidage a réussi, `false` sinon
    136139 */
    137140function taxonomie_vider_regne($regne) {
     
    154157 * @filtre
    155158 *
    156  * @param string        $regne
    157  *              Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
    158  * @param array         $meta_regne
    159  *              Meta propre au règne, créée lors du chargement de celui-ci et retournée si le règne
    160  *              existe.
     159 * @param string $regne
     160 *        Nom scientifique du règne en lettres minuscules : `animalia`, `plantae`, `fungi`.
     161 * @param array  $meta_regne
     162 *        Meta propre au règne, créée lors du chargement de celui-ci et retournée si le règne
     163 *        existe.
    161164 *
    162165 * @return bool
    163  *              `true` si le règne existe, `false` sinon.
     166 *        `true` si le règne existe, `false` sinon.
    164167 */
    165168function taxonomie_regne_existe($regne, &$meta_regne) {
     
    187190 * @filtre
    188191 *
    189  * @param string        $regne
    190  *              Nom scientifique du règne pour lequel la liste des rangs est demandée.
    191  *              Cet argument permet de remplacer le rang `phylum` par `division` qui est son synonyme
    192  *              pour les règnes fongique et végétal.
    193  * @param array         $liste_base
    194  *              Liste de base contenant les rangs par défaut à renvoyer. Il existe deux listes de base, à savoir :
    195  *              - du règne au genre (`_TAXONOMIE_RANGS_PARENTS_ESPECE`)
    196  *              - de l'espèce à la sous-forme (`_TAXONOMIE_RANGS_ESPECE_ET_FILS`)
    197  * @param array         $exclusions
    198  *              Liste des rangs à exclure de la liste fournie dans l'argument `$liste_base`
     192 * @param string $regne
     193 *        Nom scientifique du règne pour lequel la liste des rangs est demandée.
     194 *        Cet argument permet de remplacer le rang `phylum` par `division` qui est son synonyme
     195 *        pour les règnes fongique et végétal.
     196 * @param array  $liste_base
     197 *        Liste de base contenant les rangs par défaut à renvoyer. Il existe deux listes de base, à savoir :
     198 *        - du règne au genre (`_TAXONOMIE_RANGS_PARENTS_ESPECE`)
     199 *        - de l'espèce à la sous-forme (`_TAXONOMIE_RANGS_ESPECE_ET_FILS`)
     200 * @param array  $exclusions
     201 *        Liste des rangs à exclure de la liste fournie dans l'argument `$liste_base`
    199202 *
    200203 * @return array
    201  *              Liste des rangs demandée.
    202  */
    203 function taxonomie_lister_rangs($regne=_TAXONOMIE_REGNE_ANIMAL, $liste_base, $exclusions=array()) {
     204 *        Liste des rangs demandée.
     205 */
     206function taxonomie_lister_rangs($regne = _TAXONOMIE_REGNE_ANIMAL, $liste_base, $exclusions = array()) {
    204207        include_spip('inc/taxonomer');
    205208
     
    208211
    209212        if (($regne == _TAXONOMIE_REGNE_FONGIQUE)
    210         OR  ($regne == _TAXONOMIE_REGNE_VEGETAL)) {
    211                 if ($index_cherche = array_search(_TAXONOMIE_RANG_PHYLUM, $rangs))
     213                or ($regne == _TAXONOMIE_REGNE_VEGETAL)
     214        ) {
     215                if ($index_cherche = array_search(_TAXONOMIE_RANG_PHYLUM, $rangs)) {
    212216                        $rangs[$index_cherche] = _TAXONOMIE_RANG_DIVISION;
     217                }
    213218        }
    214219
     
    223228 * @filtre
    224229 *
    225  * @param int           $id_taxon
    226  *              Id du taxon pour lequel il faut fournir l'ascendance.
    227  * @param int           $tsn_parent
    228  *              TSN du parent correspondant au taxon id_taxon. Ce paramètre permet d'optimiser le traitement
    229  *              mais n'est pas obligatoire. Si il n'est pas connu lors de l'appel il faut passer `null`.
    230  * @param string        $ordre
    231  *              Classement de la liste des taxons : `descendant`(défaut) ou `ascendant`.
     230 * @param int    $id_taxon
     231 *        Id du taxon pour lequel il faut fournir l'ascendance.
     232 * @param int    $tsn_parent
     233 *        TSN du parent correspondant au taxon id_taxon. Ce paramètre permet d'optimiser le traitement
     234 *        mais n'est pas obligatoire. Si il n'est pas connu lors de l'appel il faut passer `null`.
     235 * @param string $ordre
     236 *        Classement de la liste des taxons : `descendant`(défaut) ou `ascendant`.
    232237 *
    233238 * @return array
    234  *              Liste des taxons ascendants. Chaque taxon est un tableau associatif contenant les informations
    235  *              suivantes : `id_taxon`, `tsn_parent`, `nom_scientifique`, `nom_commun`, `rang`.
    236  */
    237 function taxonomie_informer_ascendance($id_taxon, $tsn_parent=null, $ordre='descendant') {
     239 *        Liste des taxons ascendants. Chaque taxon est un tableau associatif contenant les informations
     240 *        suivantes : `id_taxon`, `tsn_parent`, `nom_scientifique`, `nom_commun`, `rang`.
     241 */
     242function taxonomie_informer_ascendance($id_taxon, $tsn_parent = null, $ordre = 'descendant') {
    238243        $ascendance = array();
    239244
     
    256261
    257262        if ($ascendance
    258         AND ($ordre == 'descendant'))
     263                and ($ordre == 'descendant')
     264        ) {
    259265                $ascendance = array_reverse($ascendance);
     266        }
    260267
    261268        return $ascendance;
     
    272279 * @uses ${service}_credit fonction de formatage des crédits propre à chaque service
    273280 *
    274  * @param int           $id_taxon
    275  *              Id du taxon pour lequel il faut fournir les crédits
    276  * @param string        $sources_specifiques
    277  *              Tableau sérialisé des sources possibles autres qu'ITIS (CINFO, WIKIPEDIA...) telles qu'enregistrées
    278  *              en base de données dans le champ `sources`.
    279  *              Ce paramètre permet d'optimiser le traitement mais n'est pas obligatoire.
     281 * @param int    $id_taxon
     282 *        Id du taxon pour lequel il faut fournir les crédits
     283 * @param string $sources_specifiques
     284 *        Tableau sérialisé des sources possibles autres qu'ITIS (CINFO, WIKIPEDIA...) telles qu'enregistrées
     285 *        en base de données dans le champ `sources`.
     286 *        Ce paramètre permet d'optimiser le traitement mais n'est pas obligatoire.
    280287 *
    281288 * @return array
    282  *              Tableau des phrases de crédits indexées par source.
    283  */
    284 function taxonomie_informer_credits($id_taxon, $sources_specifiques=null) {
     289 *        Tableau des phrases de crédits indexées par source.
     290 */
     291function taxonomie_informer_credits($id_taxon, $sources_specifiques = null) {
    285292        $sources = array();
    286293
     
    307314        return $sources;
    308315}
    309 
    310 ?>
Note: See TracChangeset for help on using the changeset viewer.