Changeset 100367 in spip-zone for _plugins_/isocode


Ignore:
Timestamp:
Nov 4, 2016, 8:00:59 PM (4 years ago)
Author:
eric@…
Message:

Renommage et un peu de refactoring pour améliorer la lisibilité du code.

Location:
_plugins_/isocode/trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/isocode/trunk/inc/isocode_sourcer.php

    r100347 r100367  
    44 * en un tableau d'éléments prêt à être inséré dans une table de la base de données.
    55 *
    6  * @package SPIP\ISOCODE\LECTURE
     6 * Dans les fonctions du package, les conventions suivantes sont utilisées:
     7 * - source          : désigne le fichier ou la page HTML à partir duquel la table des codes ISO est remplie.
     8 * - contenu         : le contenu de la source sous quelque forme que ce soit.
     9 * - élément         : un élément du contenu destiné à devenir un enregistrement de la table concernée. Un élément
     10 *                     est un tableau de couples (nom, valeur).
     11 * - éléments        : liste des éléments constitutifs du contenu de la source.
     12 * - enregistrement  : un tableau de couples (champ, valeur) pour un sous-ensemble des champs d'une table.
     13 * - enregistrements : la liste des enregistrements à insérer dans la table concernée.
     14 * - titre ou nom    : le libellé de la donnée dans la source (par ex, le titre d'une colonne dans un fichier CSV).
     15 *
     16 * @package SPIP\ISOCODE\SOURCE
    717 */
    818if (!defined('_ECRIRE_INC_VERSION')) {
     
    1929 * qui complète l'élément.
    2030 *
    21  * @api
    22  *
    2331 * @param string $service
    2432 *      Nom du service associé à la lecture de la table.
     
    3038 *      - index 0 : la liste des éléments à enregistrer dans la table concernée
    3139 *      - index 1 : le sha256 de la source des éléments de la table
    32  */
    33 function isocode_lire($service, $table) {
     40 *      - index 2 : indicateur de sha identique
     41 */
     42function lire_source($service, $table) {
    3443
    3544        // Initialisations
    36         $records = array();
    37         $f_complete_record = "${table}_complete_by_record";
    38         $f_complete_table = "${table}_complete_by_table";
    39         $sha_identique = true;
     45        $enregistrements = array();
     46        $completer_enregistrement = "${table}_completer_enregistrement";
     47        $completer_table = "${table}_completer_table";
     48        $source_identique = true;
    4049
    4150        // Inclusion des configurations et des fonctions spécifiques au service qui fournit les données
     
    4756
    4857        // Détermination de la clé primaire de la table.
    49         $primary_key_table = get_primary_key($table);
     58        $cle_primaire_table = obtenir_cle_primaire($table);
    5059
    5160        // Initialisation d'un élément de la table par défaut (uniquement les champs de base).
    5261        // Cela permet de s'assurer que chaque élément du tableau de sortie aura la même structure
    5362        // quelque soit les données lues dans la source.
    54         $default_fields = init_element_fields($table, $config['basic_fields']);
     63        $enregistrement_defaut = initialiser_enregistrement($table, $config['basic_fields']);
    5564
    5665        // Récupération du contenu du fichier ou de la page HTML source et du sha associé. Pour les fichiers CSV
    5766        // on renvoie aussi la liste des titres des colonnes qui existe toujours.
    58         list($content, $header, $sha) = get_source_content($service, $table, $config);
    59         if ($content and $sha and $default_fields) {
     67        list($contenu, $titres, $sha) = extraire_contenu_source($service, $table, $config);
     68        if ($contenu and $sha and $enregistrement_defaut) {
    6069                // On n'analyse le contenu que si celui-ci a changé (sha différent de celui stocké).
    61                 if (!isocode_comparer_sha($sha, $table)) {
    62                         $sha_identique = false;
    63                         $primary_key_values = array();
    64                         foreach ($content as $_element) {
     70                if (!sha_identique($sha, $table)) {
     71                        $source_identique = false;
     72                        $liste_cles_primaires = array();
     73                        foreach ($contenu as $_contenu) {
    6574                                // Pour chaque élément on récupère un tableau associatif [titre colonne] = valeur colonne.
    66                                 $values = get_element_values($_element, $header, $config);
     75                                $element = extraire_element($_contenu, $titres, $config);
    6776                                // Création de chaque enregistrement de la table
    68                                 $fields = $default_fields;
    69                                 $pkey_element_exists = false;
    70                                 $pkey_element = array();
    71                                 foreach ($values as $_key => $_value) {
    72                                         $key = trim($_key);
     77                                $enregistrement = $enregistrement_defaut;
     78                                $cle_primaire_existe = false;
     79                                $cle_primaire = array();
     80                                foreach ($element as $_titre => $_valeur) {
     81                                        $titre = trim($_titre);
    7382                                        // Seuls les champs identifiés dans la configuration sont récupérés dans le fichier
    74                                         if (isset($config['basic_fields'][$key])) {
    75                                                 $fields[$config['basic_fields'][$key]] = $_value ? trim($_value) : '';
     83                                        if (isset($config['basic_fields'][$titre])) {
     84                                                // Si la valeur n'est pas vide on l'affecte au champ sinon on laisse la valeur par défaut
     85                                                // déjà initialisée.
     86                                                if ($_valeur) {
     87                                                        $enregistrement[$config['basic_fields'][$titre]] = trim($_valeur);
     88                                                }
    7689                                                // Vérifier si le champ en cours fait partie de la clé primaire et élaborer la clé
    7790                                                // primaire de l'élément en cours
    78                                                 if (in_array($config['basic_fields'][$key], $primary_key_table)) {
    79                                                         $pkey_element[$config['basic_fields'][$key]] = $_value;
    80                                                         if (count($pkey_element) == count($primary_key_table)) {
    81                                                                 $pkey_element_exists = true;
     91                                                if (in_array($config['basic_fields'][$titre], $cle_primaire_table)) {
     92                                                        $cle_primaire[$config['basic_fields'][$titre]] = $_valeur;
     93                                                        if (count($cle_primaire) == count($cle_primaire_table)) {
     94                                                                $cle_primaire_existe = true;
    8295                                                        }
    8396                                                }
    8497                                        } else {
    85                                                 spip_log("Le champ <${_key}> n'existe pas dans la configuration de la table ${table}", 'isocode' . _LOG_INFO);
     98                                                spip_log("Le champ <${_titre}> n'existe pas dans la configuration de la table ${table}", 'isocode' . _LOG_INFO);
    8699                                        }
    87100                                }
    88101                                // On ajoute l'élément que si la clé primaire a bien été trouvée et si la valeur de cette clé
    89102                                // n'est pas en doublon avec un élément déjà enregistré.
    90                                 if ($pkey_element_exists) {
    91                                         ksort($pkey_element);
    92                                         $pkey_element_value = implode(',', $pkey_element);
    93                                         if (!in_array($pkey_element_value, $primary_key_values)) {
     103                                if ($cle_primaire_existe) {
     104                                        // On tri la clé primaire et on la transforme en chaine pour la tester et la stocker
     105                                        ksort($cle_primaire);
     106                                        $cle_primaire = implode(',', $cle_primaire);
     107                                        if (!in_array($cle_primaire, $liste_cles_primaires)) {
    94108                                                // On rajoute cette clé dans la liste
    95                                                 $primary_key_values[] = $pkey_element_value;
     109                                                $liste_cles_primaires[] = $cle_primaire;
    96110                                                // Si besoin on appelle une fonction pour chaque enregistrement afin de le compléter
    97                                                 if (function_exists($f_complete_record)) {
    98                                                         $fields = $f_complete_record($fields);
     111                                                if (function_exists($completer_enregistrement)) {
     112                                                        $enregistrement = $completer_enregistrement($enregistrement, $config);
    99113                                                }
    100                                                 $records[] = $fields;
     114                                                $enregistrements[] = $enregistrement;
    101115                                        } else {
    102                                                 spip_log("L'entrée de clé primaire <${pkey_element_value}> de la table <${table}> est en doublon", 'isocode' . _LOG_ERREUR);
     116                                                spip_log("L'élément de clé primaire <${cle_primaire}> de la table <${table}> est en doublon", 'isocode' . _LOG_ERREUR);
    103117                                        }
    104118                                } else {
    105                                         spip_log("L'entrée <" . var_export($_element, true) . "> de la table <${table}> n'a pas de clé primaire", 'isocode' . _LOG_ERREUR);
     119                                        spip_log("L'élément <" . var_export($_contenu, true) . "> de la table <${table}> n'a pas de clé primaire", 'isocode' . _LOG_ERREUR);
    106120                                }
    107121                        }
    108122                        // Si besoin on appelle une fonction pour toute la table
    109                         if (function_exists($f_complete_table)) {
    110                                 $records = $f_complete_table($records);
    111                         }
    112                 }
    113         }
    114 
    115         return array($records, $sha, $sha_identique);
     123                        if (function_exists($completer_table)) {
     124                                $enregistrements = $completer_table($enregistrements, $config);
     125                        }
     126                }
     127        }
     128
     129        return array($enregistrements, $sha, $source_identique);
    116130}
    117131
     
    122136 * @return array
    123137 */
    124 function get_primary_key($table) {
     138function obtenir_cle_primaire($table) {
    125139
    126140        include_spip('base/objets');
    127         $primary_key = array();
    128 
    129         if ($id_key = id_table_objet($table)) {
     141        $cle_primaire = array();
     142
     143        if ($id_table = id_table_objet($table)) {
    130144                // On stocke la clé sous forme de liste pour les tests d'appartenance.
    131                 $primary_key = explode(',', $id_key);
     145                $cle_primaire = explode(',', $id_table);
    132146                // On trie la liste et on recompose la clé sous forme de chaine pour la gestion des doublons.
    133                 sort($primary_key);
    134         }
    135 
    136         return $primary_key;
     147                sort($cle_primaire);
     148        }
     149
     150        return $cle_primaire;
    137151}
    138152
     
    144158 * @param string $table
    145159 *      Nom de la table concernée par la lecture sans le préfixe `spip_`.
    146  * @param array  $fields_config
     160 * @param array  $config_champs
    147161 *      Configuration de la correspondance entre le nom de la donnée dans la source
    148162 *      et celui du champ dans la table.
     
    150164 * @return array
    151165 */
    152 function init_element_fields($table, $fields_config) {
    153 
    154         $fields = array();
     166function initialiser_enregistrement($table, $config_champs) {
     167
     168        $enregistrement = array();
    155169
    156170        // Acquisition de la description de la table (champs, clés, jointures) et définition
     
    160174
    161175        if (!empty($description['field'])) {
    162                 foreach ($fields_config as $_field) {
    163                         if (isset($description['field'][$_field])) {
     176                foreach ($config_champs as $_champ) {
     177                        if (isset($description['field'][$_champ])) {
    164178                                // On normalise la description du champ en supprimant les espaces inutiles
    165                                 $description['field'][$_field] = preg_replace('/\s2,/', ' ', $description['field'][$_field]);
    166                                 $field_description = explode(' ', $description['field'][$_field]);
     179                                $description['field'][$_champ] = preg_replace('/\s2,/', ' ', $description['field'][$_champ]);
     180                                $description_champ = explode(' ', $description['field'][$_champ]);
    167181
    168182                                // On compare maintenant avec le format du champ
    169                                 if (isset($field_description[0])) {
    170                                         $type = strtoupper($field_description[0]);
     183                                if (isset($description_champ[0])) {
     184                                        $type = strtoupper($description_champ[0]);
    171185
    172186                                        // On cherche une instruction DEFAULT
    173                                         $default = null;
    174                                         if (preg_match($regexp_default, $description['field'][$_field], $matches)) {
    175                                                 $default = $matches[1];
     187                                        $defaut = null;
     188                                        if (preg_match($regexp_default, $description['field'][$_champ], $matches)) {
     189                                                $defaut = $matches[1];
    176190                                        }
    177191
     
    180194                                                or (strpos($type, 'BLOB') !== false) or (strpos($type, 'BINARY') !== false)
    181195                                        ) {
    182                                                 $fields[$_field] = ($default != null) ? $default : '';
     196                                                $enregistrement[$_champ] = ($defaut != null) ? $defaut : '';
    183197                                        } elseif (strpos($type, 'DATE') !== false) {
    184                                                 $fields[$_field] = ($default != null) ? $default : '0000-00-00 00:00:00';
     198                                                $enregistrement[$_champ] = ($defaut != null) ? $defaut : '0000-00-00 00:00:00';
    185199                                        } else {
    186                                                 $fields[$_field] = ($default != null) ? intval($default) : 0;
     200                                                $enregistrement[$_champ] = ($defaut != null) ? intval($defaut) : 0;
    187201                                        }
    188202                                } else {
    189203                                        // On a un problème de configuration: on le trace et on arrête la boucle
    190204                                        // La table ne sera pas mise à jour.
    191                                         $fields = array();
    192                                         spip_log("La description du champ <${_field}> de la table <${table}> est mal formée", 'isocode' . _LOG_ERREUR);
     205                                        $enregistrement = array();
     206                                        spip_log("La description du champ <${_champ}> de la table <${table}> est mal formée", 'isocode' . _LOG_ERREUR);
    193207                                        break;
    194208                                }
     
    196210                                // On a un problème de configuration: on le trace et on arrête la boucle.
    197211                                // La table ne sera pas mise à jour.
    198                                 $fields = array();
    199                                 spip_log("Le champ <${_field}> n'est pas un champ de la table <${table}>", 'isocode' . _LOG_ERREUR);
     212                                $enregistrement = array();
     213                                spip_log("Le champ <${_champ}> n'est pas un champ de la table <${table}>", 'isocode' . _LOG_ERREUR);
    200214                                break;
    201215                        }
     
    203217        }
    204218
    205         return $fields;
     219        return $enregistrement;
    206220}
    207221
     
    214228 * @return array
    215229 */
    216 function get_source_content($service, $table, $config) {
     230function extraire_contenu_source($service, $table, $config) {
    217231
    218232        // Initialisation des données de sortie
    219         $content = array();
    220         $header = array();
     233        $contenu = array();
     234        $titres = array();
    221235        $sha = false;
    222236
     
    230244                        if ($config['parsing']['element']['method'] == 'explode') {
    231245                                // On récupére donc un tableau des éléments à lire en utilisant la fonction explode
    232                                 $content = explode($config['parsing']['element']['delimiter'], $flux['page']);
     246                                $contenu = explode($config['parsing']['element']['delimiter'], $flux['page']);
    233247                        } else {
    234248                                // TODO : c'est une regexp... à compléter
     
    238252                // La source est un fichier.
    239253                // On construit son nom et on lit son contenu en fonction du type du fichier.
    240                 $file = find_in_path("services/${service}/${table}{$config['extension']}");
    241                 if (file_exists($file) and ($sha = sha1_file($file))) {
     254                $fichier = find_in_path("services/${service}/${table}{$config['extension']}");
     255                if (file_exists($fichier) and ($sha = sha1_file($fichier))) {
    242256                        if ($config['populating'] == 'file_csv') {
    243                                 $lines = file($file);
    244                                 if ($lines) {
     257                                $lignes = file($fichier);
     258                                if ($lignes) {
    245259                                        // La première ligne d'un CSV contient toujours les titres des colonnes.
    246260                                        // On sauvegarde ces titres dans une variable et on élimine la ligne du contenu retourné.
    247                                         $header = explode($config['delimiter'], trim(array_shift($lines), "\r\n"));
    248                                         $header = array_map('trim', $header);
     261                                        $titres = explode($config['delimiter'], trim(array_shift($lignes), "\r\n"));
     262                                        $titres = array_map('trim', $titres);
    249263                                        // On renvoie le contenu sans titre
    250                                         $content = $lines;
     264                                        $contenu = $lignes;
    251265                                }
    252266                        } elseif ($config['populating'] == 'file_xml') {
    253267                                include_spip('inc/flock');
    254                                 lire_fichier($file, $xml);
    255                                 $xml_tree = json_decode(json_encode(simplexml_load_string($xml)), true);
     268                                lire_fichier($fichier, $xml);
     269                                $arbre = json_decode(json_encode(simplexml_load_string($xml)), true);
    256270
    257271                                include_spip('inc/filtres');
    258                                 if (table_valeur($xml_tree, $config['base'], '')) {
    259                                         $content = table_valeur($xml_tree, $config['base'], '');
    260                                 }
    261                         }
    262                 }
    263         }
    264 
    265         return array($content, $header, $sha);
    266 }
    267 
    268 
    269 /**
    270  * @param $element
    271  * @param $header
     272                                if (table_valeur($arbre, $config['base'], '')) {
     273                                        $contenu = table_valeur($arbre, $config['base'], '');
     274                                }
     275                        }
     276                }
     277        }
     278
     279        return array($contenu, $titres, $sha);
     280}
     281
     282
     283/**
     284 * @param $contenu
     285 * @param $titres
    272286 * @param $config
    273287 *
    274288 * @return array
    275289 */
    276 function get_element_values($element, $header, $config) {
    277 
    278         $values = array();
     290function extraire_element($contenu, $titres, $config) {
     291
     292        $element = array();
    279293
    280294        if ($config['populating'] == 'file_csv') {
    281295                // Chaque valeur de colonne est séparée par le délimiteur configuré.
    282                 $columns = explode($config['delimiter'], trim($element, "\r\n"));
     296                $valeurs = explode($config['delimiter'], trim($contenu, "\r\n"));
    283297                // On construit un tableau associatif [nom colonne] => valeur colonne
    284                 foreach ($header as $_key => $_header) {
    285                         $values[$_header] = trim($columns[$_key]);
     298                foreach ($titres as $_cle => $_titre) {
     299                        $element[$_titre] = trim($valeurs[$_cle]);
    286300                }
    287301        } elseif ($config['populating'] == 'page_text') {
    288302                // Chaque couple (nom donnée, valeur donnée) est identifiée par une REGEXP configurée
    289                 if (preg_match_all($config['parsing']['field']['regexp'], $element, $matches)) {
    290                         // L'index 1 correspond à la liste des nom de données et l'index 2 à la liste des
    291                         // valeur de données correspondantes.
    292                         // Il faut donc reconstruire un tableau associatif [nom donnée] => valeur donnée
    293                         foreach ($matches[1] as $_key => $_header) {
    294                                 $values[trim($_header)] = $matches[2][trim($_key)];
     303                if (preg_match_all($config['parsing']['field']['regexp'], $contenu, $matches)) {
     304                        // L'index 1 correspond à la liste des titres et l'index 2 à la liste des
     305                        // valeurs correspondantes.
     306                        // Il faut donc reconstruire un tableau associatif [nom] => valeur
     307                        foreach ($matches[1] as $_cle => $_titre) {
     308                                $element[trim($_titre)] = $matches[2][trim($_cle)];
    295309                        }
    296310                }
     
    298312                // Fichier XML.
    299313                // Le tableau associatif (nom donnée, valeur donnée) est déjà correctement formé.
    300                 $values = $element;
    301         }
    302 
    303         return $values;
     314                $element = $contenu;
     315        }
     316
     317        return $element;
    304318}
    305319
     
    314328 *      SHA à comparer à celui de la table.
    315329 * @param string $table
    316  *      Nom de la table de code ISO (sans préfixe `spip_`) dont il faut comparer le sha
    317  *      stoké dans sa meta de chargement.
     330 *      Nom de la table sans préfixe `spip_` dont il faut comparer le sha
     331 *      stocké dans sa meta de chargement.
    318332 *
    319333 * @return bool
    320334 *      `true` si le sha passé en argument est identique au sha stocké pour la table choisie, `false` sinon.
    321335 */
    322 function isocode_comparer_sha($sha, $table) {
     336function sha_identique($sha, $table) {
    323337
    324338        $sha_identique = false;
  • _plugins_/isocode/trunk/isocode_fonctions.php

    r100347 r100367  
    1919 * @uses isocode_lister_tables()
    2020 * @uses isocode_trouver_service()
    21  * @uses isocode_lire()
     21 * @uses lire_source()
    2222 * @uses isocode_vider_tables()
    2323 *
     
    7070                foreach ($tables as $_table) {
    7171                        $erreur_table = true;
    72                         $sha_identique = false;
     72                        $source_identique = false;
    7373
    7474                        // On détermine le service qui supporte le chargement de la table
     
    8181                                // sur le SHA.
    8282                                include_spip('inc/isocode_sourcer');
    83                                 list($records, $sha, $sha_identique) = isocode_lire($service, $_table);
    84                                 if ($records) {
     83                                list($enregistrements, $sha, $source_identique) = lire_source($service, $_table);
     84                                if ($enregistrements) {
    8585                                        // Suppression des éléments éventuels déjà chargés. On ne gère pas d'erreur
    8686                                        // sur ce traitement car elle sera forcément détectée lors de l'insertion qui suit.
     
    8888
    8989                                        // Insertion dans la base de données des éléments extraits
    90                                         $sql_ok = sql_insertq_multi("spip_${_table}", $records);
     90                                        $sql_ok = sql_insertq_multi("spip_${_table}", $enregistrements);
    9191                                        if ($sql_ok !== false) {
    9292                                                // On stocke les informations de chargement de la table dans une meta.
     
    9494                                                        'service' => $service,
    9595                                                        'sha'     => $sha,
    96                                                         'nbr'     => count($records),
     96                                                        'nbr'     => count($enregistrements),
    9797                                                        'maj'     => date('Y-m-d H:i:s')
    9898                                                );
     
    108108                        if ($erreur_table) {
    109109                                $retour['ok'] = false;
    110                                 if ($sha_identique) {
     110                                if ($source_identique) {
    111111                                        $retour['tables_sha'][] = $_table;
    112112                                } else {
  • _plugins_/isocode/trunk/services/iana/iana_api.php

    r99228 r100367  
    11<?php
    22/**
    3  * Ce fichier contient l'ensemble des constantes et fonctions implémentant les services IANA.
     3 * Ce fichier contient l'ensemble des constantes et fonctions implémentant le service IANA.
    44 *
    55 * @package SPIP\ISOCODE\SERVICES\IANA
  • _plugins_/isocode/trunk/services/iso/iso_api.php

    r100330 r100367  
    11<?php
    22/**
    3  * Ce fichier contient l'ensemble des constantes et fonctions implémentant les services ISO.
     3 * Ce fichier contient l'ensemble des constantes et fonctions implémentant le service ISO.
    44 *
    55 * @package SPIP\ISOCODE\SERVICES\ISO
     
    1313        /**
    1414         * URL de base pour charger la page de documentation d'un code de langue alpha-3 sur le site
    15          * sil.org
     15         * sil.org. Complément à la table iso639families
    1616         */
    1717        define('_ISOCODE_SIL_ISO639_3_ENDPOINT', 'http://www-01.sil.org/iso639-3/documentation.asp?id=');
     
    2020        /**
    2121         * URL de base pour charger la page du tableau de la hiérarchie ISO-639-5 sur le site
    22          * de la Library of Congress.
     22         * de la Library of Congress. Complément à la table iso639families
    2323         */
    2424        define('_ISOCODE_LOC_ISO639_5_HIERARCHY', 'https://www.loc.gov/standards/iso639-5/hier.php');
     25}
     26if (!defined('_ISOCODE_GEONAMES_INFORMATIONS_PAYS')) {
     27        /**
     28         * Chemin du fichier Geonames contenant des informations géographiques sur les pays.
     29         * Complément à la table iso639countries.
     30         */
     31        define('_ISOCODE_GEONAMES_INFORMATIONS_PAYS', 'services/iso/iso3166countries-geonames-info.txt');
    2532}
    2633if (!defined('_ISOCODE_IOTA_ISO4217_SYMBOL')) {
     
    2835         * URL de base pour charger la page du tableau des devises ISO-4217 sur le site
    2936         * de IOTA Finance qui permet de compléter les informations de base de l'ISO-4217.
     37         * Complément à la table iso639currencies.
    3038         */
    3139        define('_ISOCODE_IOTA_ISO4217_SYMBOL', 'http://www.iotafinance.com/Codes-ISO-Devises.html');
     
    165173// ----------------------------------------------------------------------------
    166174
    167 function iso639families_complete_by_record($fields) {
    168 
    169         // Initialisation des champs additionnels
    170         $sil_to_spip = $GLOBALS['isocode']['iso']['tables']['iso639families']['addon_fields']['sil'];
    171         foreach ($sil_to_spip as $_label => $_field) {
    172                 $fields[$_field] = '';
     175function iso639families_completer_enregistrement($enregistrement, $config) {
     176
     177        // Initialisation des champs additionnels qui sont tous de type chaine dans l'enregistrement
     178        // passé en argument (qui contient déjà les champs de base).
     179        $config_champs_sil = $config['addon_fields']['sil'];
     180        foreach ($config_champs_sil as $_champ) {
     181                $enregistrement[$_champ] = '';
    173182        }
    174183
    175184        // On récupère la page de description de la famille sur le site SIL.
    176185        include_spip('inc/distant');
    177         $url = _ISOCODE_SIL_ISO639_3_ENDPOINT . $fields['code_639_5'];
    178         $options = array('transcoder' => true);
    179         $flux = recuperer_url($url, $options);
     186        $url = _ISOCODE_SIL_ISO639_3_ENDPOINT . $enregistrement['code_639_5'];
     187        $flux = recuperer_url($url, array('transcoder' => true));
    180188
    181189        // On décrypte la page et principalement le premier tableau pour en extraire les données
     
    183191        // - scope : C(ollective)
    184192        // - equivalent : éventuellement le code ISO-639-1
    185         // - code set : ISO-639-5 et/ou ISO-639-2
     193        // - code set(s) : ISO-639-5 et/ou ISO-639-2
    186194        include_spip('inc/filtres');
    187195        $table = extraire_balise($flux['page'], 'table');
    188196        if ($table) {
    189197                // On extrait la première table de la page qui contient les données voulues
    190                 $rows = extraire_balises($table, 'tr');
    191                 if ($rows) {
    192                         foreach ($rows as $_row) {
     198                $lignes = extraire_balises($table, 'tr');
     199                if ($lignes) {
     200                        foreach ($lignes as $_ligne) {
    193201                                // Chaque ligne de la table est composée de deux colonnes, le première le libellé
    194202                                // et la deuxième la valeur.
    195                                 $columns = extraire_balises($_row, 'td');
    196                                 $columns = array_map('supprimer_tags', $columns);
    197                                 if (count($columns) == 2) {
    198                                         $keys = explode(':', trim($columns[0]));
    199                                         $key = trim($keys[0]);
    200                                         $value = str_replace(' ', '', trim($columns[1]));
    201                                         switch ($key) {
    202                                                 case 'Equivalent':
    203                                                         $equivalent = explode(':', $value);
    204                                                         $fields[$sil_to_spip[$key]] = isset($equivalent[1]) ? trim($equivalent[1]) : '';
    205                                                         break;
    206                                                 case 'Code sets':
    207                                                 case 'Code set':
    208                                                         $fields[$sil_to_spip[$key]] = str_replace('and', ',', $value);
    209                                                         break;
    210                                                 case 'Scope':
    211                                                         $fields[$sil_to_spip[$key]] = substr($value, 0, 1);
    212                                                         break;
    213                                                 default:
    214                                                         break;
     203                                $colonnes = extraire_balises($_ligne, 'td');
     204                                $colonnes = array_map('supprimer_tags', $colonnes);
     205                                $colonnes = array_map('trim', $colonnes);
     206                                if (count($colonnes) == 2) {
     207                                        $titre = trim(substr($colonnes[0], 0, strpos($colonnes[0], ':')));
     208                                        if (isset($config_champs_sil[$titre])) {
     209                                                $valeur = str_replace(' ', '', $colonnes[1]);
     210                                                switch ($titre) {
     211                                                        case 'Equivalent':
     212                                                                $equivalent = explode(':', $valeur);
     213                                                                $enregistrement[$config_champs_sil[$titre]] = isset($equivalent[1]) ? trim($equivalent[1]) : '';
     214                                                                break;
     215                                                        case 'Code sets':
     216                                                        case 'Code set':
     217                                                                $enregistrement[$config_champs_sil[$titre]] = str_replace('and', ',', $valeur);
     218                                                                break;
     219                                                        case 'Scope':
     220                                                                $enregistrement[$config_champs_sil[$titre]] = substr($valeur, 0, 1);
     221                                                                break;
     222                                                        default:
     223                                                                break;
     224                                                }
    215225                                        }
    216226                                }
     
    219229        }
    220230
    221         return $fields;
    222 }
    223 
    224 
    225 function iso639families_complete_by_table($records) {
     231        return $enregistrement;
     232}
     233
     234
     235function iso639families_completer_table($enregistrements, $config) {
    226236
    227237        // Initialisation des champs additionnels
    228238        $hierarchies = array();
    229         $loc_to_spip = $GLOBALS['isocode']['iso']['tables']['iso639families']['addon_fields']['loc'];
     239        $config_champs_loc = $config['addon_fields']['loc'];
    230240
    231241        // On récupère la page de description de la famille sur le site SIL.
    232242        include_spip('inc/distant');
    233243        $url = _ISOCODE_LOC_ISO639_5_HIERARCHY;
    234         $options = array('transcoder' => true);
    235         $flux = recuperer_url($url, $options);
     244        $flux = recuperer_url($url, array('transcoder' => true));
    236245
    237246        // On décrypte la page et principalement le tableau pour en extraire la colonne hiérarchie
     
    241250        if ($table) {
    242251                // On extrait la première table de la page qui contient les données voulues
    243                 $rows = extraire_balises($table, 'tr');
    244                 if ($rows) {
     252                $lignes = extraire_balises($table, 'tr');
     253                if ($lignes) {
    245254                        // La première ligne du tableau est celle des titres de colonnes : on la supprime.
    246                         array_shift($rows);
    247                         foreach ($rows as $_row) {
     255                        array_shift($lignes);
     256                        foreach ($lignes as $_ligne) {
    248257                                // Chaque ligne de la table est composée de deux colonnes, le première le libellé
    249258                                // et la deuxième la valeur.
    250                                 $columns = extraire_balises($_row, 'td');
    251                                 $columns = array_map('supprimer_tags', $columns);
    252                                 if (count($columns) >= 2) {
     259                                $colonnes = extraire_balises($_ligne, 'td');
     260                                $colonnes = array_map('supprimer_tags', $colonnes);
     261                                if (count($colonnes) >= 2) {
    253262                                        // La première colonne contient la hiérarchie et la seconde le code alpha-3 de la famille.
    254                                         $code = trim($columns[1]);
    255                                         $hierarchies[$code] = str_replace(array(' ', ':'), array('', ','), trim($columns[0]));
     263                                        $code = trim($colonnes[1]);
     264                                        $hierarchies[$code] = str_replace(array(' ', ':'), array('', ','), trim($colonnes[0]));
    256265                                }
    257266                        }
     
    261270        // On complète maintenant le tableau des enregistrements avec la colonne additionnelle hierarchy et la colonne
    262271        // dérivée parent qui ne contient que le code alpha-3 de la famille parente si elle existe.
    263         foreach ($records as $_cle => $_record) {
    264                 $code = $_record['code_639_5'];
    265                 $records[$_cle]['parent'] = '';
     272        foreach ($enregistrements as $_cle => $_enregistrement) {
     273                $code = $_enregistrement['code_639_5'];
     274                $enregistrements[$_cle]['parent'] = '';
    266275                if (isset($hierarchies[$code])) {
    267                         $records[$_cle][$loc_to_spip['Hierarchy']] = $hierarchies[$code];
     276                        $enregistrements[$_cle][$config_champs_loc['Hierarchy']] = $hierarchies[$code];
    268277                        // Calcul du parent : si la hierarchie ne contient qu'un code c'est qu'il n'y a pas de parent.
    269278                        // Sinon, le parent est le premier code qui précède le code du record.
     
    271280                        if (count($parents) > 1) {
    272281                                array_pop($parents);
    273                                 $records[$_cle]['parent'] = array_pop($parents);
     282                                $enregistrements[$_cle]['parent'] = array_pop($parents);
    274283                        }
    275284                } else {
    276                         $records[$_cle][$loc_to_spip['Hierarchy']] = '';
    277                 }
    278         }
    279 
    280         return $records;
    281 }
    282 
    283 
    284 function iso3166countries_complete_by_table($records) {
     285                        $enregistrements[$_cle][$config_champs_loc['Hierarchy']] = '';
     286                }
     287        }
     288
     289        return $enregistrements;
     290}
     291
     292
     293function iso3166countries_completer_table($enregistrements, $config) {
    285294
    286295        // Initialisation des champs additionnels
    287         $add_columns = array();
    288         $geo_to_spip = $GLOBALS['isocode']['iso']['tables']['iso3166countries']['addon_fields']['geonames'];
     296        $enregistrements_geo = array();
     297        $config_champs_geo = $config['addon_fields']['geonames'];
    289298
    290299        // Lecture du fichier CSV geonames-countryInfo.txt pour récupérer les informations additionnelles.
    291300        // Le délimiteur est une tabulation.
    292         $file = find_in_path('services/iso/iso3166countries-geonames-info.txt');
    293         $delimiter = "\t";
    294         $lines = file($file);
    295         if ($lines) {
    296                 $headers = array();
    297                 foreach ($lines as $_number => $_line) {
    298                         $values = explode($delimiter, trim($_line, "\r\n"));
    299                         if ($_number == 0) {
     301        $fichier = find_in_path(_ISOCODE_GEONAMES_INFORMATIONS_PAYS);
     302        $separateur = "\t";
     303        $lignes = file($fichier);
     304        if ($lignes) {
     305                $titres = array();
     306                $index_code_pays = null;
     307                foreach ($lignes as $_numero => $_ligne) {
     308                        $valeurs = explode($separateur, trim($_ligne, "\r\n"));
     309                        if ($_numero == 0) {
    300310                                // Stockage des noms de colonnes car la première ligne contient toujours le header et de
    301311                                // l'index correspondant au code ISO-3166 alpha2 du pays qui se nomme ISO dans le fichier CSV.
    302                                 $headers = $values;
    303                                 $index_iso3166_alpha2 = array_search('ISO', $headers);
     312                                $titres = $valeurs;
     313                                $index_code_pays = array_search('ISO', $titres);
    304314                        } else {
    305                                 // On extrait de chaque ligne les informations additionnelles ainsi que le code alpha2 du pays
     315                                // On extrait de chaque ligne les informations additionnelles du pays ainsi que le code alpha2 du pays
    306316                                // qui servira d'index du tableau constitué.
    307317                                // On ne sélectionne que les colonnes correspondant à des champs additionnels.
    308                                 $fields = array();
    309                                 foreach ($headers as $_cle => $_header) {
    310                                         if (isset($geo_to_spip[trim($_header)])) {
    311                                                 $fields[$geo_to_spip[trim($_header)]] = isset($values[$_cle]) ? trim($values[$_cle]) : '';
     318                                $enregistrement_geo = initialiser_enregistrement('iso3166countries', $config_champs_geo);
     319                                foreach ($titres as $_cle => $_titre) {
     320                                        $titre = trim($_titre);
     321                                        if (isset($config_champs_geo[$titre]) and !empty($valeurs[$_cle])) {
     322                                                $enregistrement_geo[$config_champs_geo[$titre]] = trim($valeurs[$_cle]);
    312323                                        }
    313324                                }
    314                                 if (isset($values[$index_iso3166_alpha2])) {
    315                                         $add_columns[$values[$index_iso3166_alpha2]] = $fields;
     325                                if (isset($valeurs[$index_code_pays])) {
     326                                        $enregistrements_geo[$valeurs[$index_code_pays]] = $enregistrement_geo;
    316327                                }
    317328                        }
     
    319330        }
    320331
    321 
    322332        // On complète maintenant le tableau des enregistrements avec la colonne additionnelle hierarchy et la colonne
    323333        // dérivée parent qui ne contient que le code alpha-3 de la famille parente si elle existe.
    324         foreach ($records as $_cle => $_record) {
    325                 $code = $_record['code_alpha2'];
    326                 if (isset($add_columns[$code])) {
    327                         $records[$_cle] = array_merge($records[$_cle], $add_columns[$code]);
    328                 }
    329         }
    330 
    331         return $records;
    332 }
     334        foreach ($enregistrements as $_cle => $_enregistrement) {
     335                $code = $_enregistrement['code_alpha2'];
     336                if (isset($enregistrements_geo[$code])) {
     337                        $enregistrements[$_cle] = array_merge($enregistrements[$_cle], $enregistrements_geo[$code]);
     338                }
     339        }
     340
     341        return $enregistrements;
     342}
     343
     344
     345function iso4217currencies_completer_table($enregistrements, $config) {
     346
     347
     348        return $enregistrements;
     349}
Note: See TracChangeset for help on using the changeset viewer.