Changeset 100264 in spip-zone for _plugins_/isocode


Ignore:
Timestamp:
Oct 30, 2016, 9:06:22 AM (4 years ago)
Author:
eric@…
Message:

Ne pas recharger une table si aucune modification des fichiers ou pages source n'est trouvée.

Location:
_plugins_/isocode/trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/isocode/trunk/base/isocode_declarations.php

    r99234 r100264  
    2222 * - `spip_iso639families`, qui contient les familles et groupes de langues ISO-639-5,
    2323 *
    24  * une table `spip_iso15924scripts` qui contient les codets d'écriture à 4 lettres et leur définition en
    25  * français et en anglais.
    26  *
    27  * et une table `spip_iana5646subtags` qui contient les codes des sous-étiquettes des étiquettes de langue
     24 * Le plugin déclare aussi une table `spip_iso15924scripts` qui contient les codets d'écriture à 4 lettres et leur définition en
     25 * français et en anglais et une table `spip_iana5646subtags` qui contient les codes des sous-étiquettes des étiquettes de langue
    2826 * construites selon la RFC 5646.
     27 *
     28 * Enfin, la plugin déclare une table `spip_iso15924countries` qui contient les indicatifs ISO-3166 des pays.
    2929 *
    3030 * @pipeline declarer_tables_principales
     
    135135        // Table des indicatifs d'écritures (ISO 15924) : spip_iso15924scripts
    136136        $table_scripts = array(
    137                 'code_15924'  => "char(4) DEFAULT '' NOT NULL",                  // The four-letter identifier
    138                 'label_en'    => "varchar(255) DEFAULT '' NOT NULL",             // English script name
    139                 'label_fr'    => "varchar(255) DEFAULT '' NOT NULL",             // french script name
    140                 'code_num'    => "char(3) DEFAULT '' NOT NULL",                  // Numeric identifier
    141                 'alias_en'    => "varchar(32) DEFAULT '' NOT NULL",              // Unicode alias showing how ISO 15924 code relate to script names defined in Unicode.
     137                'code_15924'  => "char(4) DEFAULT '' NOT NULL",                     // The four-letter identifier
     138                'label_en'    => "varchar(255) DEFAULT '' NOT NULL",                // English script name
     139                'label_fr'    => "varchar(255) DEFAULT '' NOT NULL",                // french script name
     140                'code_num'    => "char(3) DEFAULT '' NOT NULL",                     // Numeric identifier
     141                'alias_en'    => "varchar(32) DEFAULT '' NOT NULL",                 // Unicode alias showing how ISO 15924 code relate to script names defined in Unicode.
    142142                'date_ref'    => "datetime DEFAULT '0000-00-00 00:00:00' NOT NULL", // The reference date to follow changes
    143143                'maj'         => 'timestamp'
     
    169169                array('field' => &$table_countries, 'key' => &$table_countries_key);
    170170
    171         // ------------------------------------------------------------
     171        // -----------------------------------------------------------------------------------------
    172172        // Table reproduisant le registre IANA des sous-étiquettes de langues : spip_iana5646subtags
    173173        $table_subtags = array(
  • _plugins_/isocode/trunk/demo/isocode.html

    r99066 r100264  
    1212        <h2>Verifier les codes</h2>
    1313<?php
    14 
    15         include_spip('services/iso/iso_api');
    16         $fields = iso639families_complete(array('code_639_5' => 'eng'), $GLOBALS['iso_service']['fields']['iso639families']);
    17         var_dump($fields);
    18         $fields = iso639families_complete(array('code_639_5' => 'bih'), $GLOBALS['iso_service']['fields']['iso639families']);
    19         var_dump($fields);
    20         $fields = iso639families_complete(array('code_639_5' => 'aav'), $GLOBALS['iso_service']['fields']['iso639families']);
    21         var_dump($fields);
    22         die();
    23 
    2414        $codes = isocode_verifier_codes_spip();
    2515        if (isset($codes['ok']['iso6395'])) var_dump('SPIP 5', count($codes['ok']['iso6395']), $codes['ok']['iso6395']);
  • _plugins_/isocode/trunk/formulaires/isocode_gerer_table.php

    r99228 r100264  
    100100                // La fonction de chargement de la table lance un vidage préalable si la table
    101101                // demandé est déjà chargée.
    102                 list($action_ok, $tables_nok) = isocode_charger_tables($tables);
    103                 $message = $action_ok
    104                         ? _T('isocode:succes_charger_table')
    105                         : _T('isocode:erreur_charger_table', array('tables' => implode(', ', $tables_nok)));
     102                list($action_ok, $tables_nok, $tables_inchangees) = isocode_charger_tables($tables);
     103                if ($action_ok) {
     104                        $message = _T('isocode:succes_charger_table');
     105                } else {
     106                        $message = '';
     107                        if ($tables_inchangees) {
     108                                $message .= _T('isocode:notice_charger_table', array('tables' => implode(', ', $tables_inchangees)));
     109                        }
     110                        if ($tables_nok) {
     111                                $message .= $message ? '<br/>' : '';
     112                                $message .= _T('isocode:erreur_charger_table', array('tables' => implode(', ', $tables_nok)));
     113                        }
     114                }
    106115        }
    107116
  • _plugins_/isocode/trunk/inc/isocode_read_file_csv.php

    r99228 r100264  
    11<?php
    22/**
    3  * Ce fichier contient l'ensemble des fonctions implémentant l'API du plugin Codes de Langues.
     3 * Ce fichier contient la fonction générique de lecture d'un fichier CSV en un tableau d'éléments d'une
     4 * table de la base de données.
    45 *
    56 * @package SPIP\ISOCODE\OUTILS
     
    1112
    1213/**
    13  * @param string $service
    14  * @param string $table
     14 * Constitue, à partir d'un fichier CSV donné, un tableau des éléments prêt à être inséré dans une table
     15 * de la base de données.
     16 * La fonction utilise le service et le nom de table pour récupérer la configuration permettant l'analyse
     17 * du fichier et sa traduction en élements de la table (délimiteur, nom des colonnes...).
     18 * Il est possible, pour chaque élément ou pour l'ensemble d'appliquer une fonction spécifique à la table
     19 * qui complète l'élément.
    1520 *
    1621 * @api
    1722 *
     23 * @param string $service
     24 *              Nom du service associé à la lecture de la table.
     25 * @param string $table
     26 *              Nom de la table concernée par la lecture du fichier CSV.
     27 * @param string $sha_stocke
     28 *              SHA du fichier CSV stocké dans la meta associée à la table ou `false` si la table n'est pas chargée.
     29 *
    1830 * @return array
     31 *              Tableau à deux éléments:
     32 *              - index 0 : la liste des éléments à enregistrer dans la table concernée
     33 *              - index 1 : le sha256 du fichier CSV source des éléments de la table
    1934 */
    2035function inc_isocode_read_file_csv($service, $table) {
     
    2237        // Initialisations
    2338        $records = array();
    24         $sha_file = '';
     39        $sha_file = false;
    2540        $f_complete_record = "${table}_complete_by_record";
    2641        $f_complete_table = "${table}_complete_by_table";
     
    3853        $file = find_in_path("services/${service}/${table}${file_extension}");
    3954        if (file_exists($file) and ($sha_file = sha1_file($file))) {
    40                 // Lecture du fichier au format CSV comme un fichier texte sachant :
    41                 // - que le délimiteur de colonne est configuré pour chaque table
    42                 // - et qu'il n'y a jamais de caractère d'enclosure dans ces fichiers csv
    43                 $lines = file($file);
    44                 if ($lines) {
    45                         $headers = array();
    46                         foreach ($lines as $_number => $_line) {
    47                                 $values = explode($delimiter, trim($_line, "\r\n"));
    48                                 if ($_number == 0) {
    49                                         // Stockage des noms de colonnes car la première ligne contient toujours le header
    50                                         $headers = $values;
    51                                 } else {
    52                                         // Création de chaque enregistrement de la table
    53                                         $fields = array();
    54                                         foreach ($headers as $_cle => $_header) {
    55                                                 $fields[$fields_config[trim($_header)]] = isset($values[$_cle]) ? trim($values[$_cle]) : '';
     55                // On ne lit le fichier que si celui-ci a changé.
     56                include_spip('isocode_fonctions');
     57                if (!isocode_comparer_sha($sha_file, $table)) {
     58                        // Lecture du fichier au format CSV comme un fichier texte sachant :
     59                        // - que le délimiteur de colonne est configuré pour chaque table
     60                        // - et qu'il n'y a jamais de caractère d'enclosure dans ces fichiers csv
     61                        $lines = file($file);
     62                        if ($lines) {
     63                                $headers = array();
     64                                foreach ($lines as $_number => $_line) {
     65                                        $values = explode($delimiter, trim($_line, "\r\n"));
     66                                        if ($_number == 0) {
     67                                                // Stockage des noms de colonnes car la première ligne contient toujours le header
     68                                                $headers = $values;
     69                                        } else {
     70                                                // Création de chaque enregistrement de la table
     71                                                $fields = array();
     72                                                foreach ($headers as $_cle => $_header) {
     73                                                        $fields[$fields_config[trim($_header)]] = isset($values[$_cle]) ? trim($values[$_cle]) : '';
     74                                                }
     75                                                // Si besoin on appelle une fonction pour chaque enregistrement afin de le compléter
     76                                                if (function_exists($f_complete_record)) {
     77                                                        $fields = $f_complete_record($fields);
     78                                                }
     79                                                $records[] = $fields;
    5680                                        }
    57                                         // Si besoin on appelle une fonction pour chaque enregistrement afin de le compléter
    58                                         if (function_exists($f_complete_record)) {
    59                                                 $fields = $f_complete_record($fields);
    60                                         }
    61                                         $records[] = $fields;
    6281                                }
    63                         }
    64                         // Si besoin on appelle une fonction pour toute la table
    65                         if (function_exists($f_complete_table)) {
    66                                 $records = $f_complete_table($records);
     82                                // Si besoin on appelle une fonction pour toute la table
     83                                if (function_exists($f_complete_table)) {
     84                                        $records = $f_complete_table($records);
     85                                }
    6786                        }
    6887                }
  • _plugins_/isocode/trunk/inc/isocode_read_page_text.php

    r99231 r100264  
    11<?php
    22/**
    3  * Ce fichier contient l'ensemble des fonctions implémentant l'API du plugin Codes de Langues.
     3 * Ce fichier contient la fonction générique de lecture d'une page HTML au format texte en un tableau d'éléments d'une
     4 * table de la base de données.
    45 *
    56 * @package SPIP\ISOCODE\OUTILS
     
    1112
    1213/**
     14 * Constitue, à partir d'une page HTML au format texte, un tableau des éléments prêt à être inséré dans une table
     15 * de la base de données.
     16 * La fonction utilise le service et le nom de table pour récupérer la configuration permettant l'analyse
     17 * du fichier et sa traduction en élements de la table (délimiteur ou regexp, nom des colonnes...).
     18 * Il est possible, pour chaque élément ou pour l'ensemble d'appliquer une fonction spécifique à la table
     19 * qui complète l'élément.
     20 *
     21 * @api
     22 *
    1323 * @param string $service
     24 *              Nom du service associé à la lecture de la table.
    1425 * @param string $table
     26 *              Nom de la table concernée par la lecture de la page HTML.
     27 * @param string $sha_stocke
     28 *              SHA de la page HTML stocké dans la meta associée à la table ou `false` si la table n'est pas chargée.
    1529 *
    1630 * @return array
     31 *              Tableau à deux éléments:
     32 *              - index 0 : la liste des éléments à enregistrer dans la table concernée
     33 *              - index 1 : le sha256 du fichier CSV source des éléments de la table
    1734 */
    1835function inc_isocode_read_page_text($service, $table) {
     
    2037        // Initialisations
    2138        $records = array();
    22         $sha_file = false;
     39        $sha_page = false;
    2340        $f_complete_record = "${table}_complete_by_record";
    2441        $f_complete_table = "${table}_complete_by_table";
     
    3350        $fields_config = $GLOBALS['isocode'][$service]['tables'][$table]['basic_fields'];
    3451
    35         // Acquisition de la page sur le site de l'IANA
     52        // Acquisition de la page ciblée par l'url
    3653        include_spip('inc/distant');
    3754        $options = array();
    3855        $flux = recuperer_url($url, $options);
    3956
    40         if (!empty($flux['page'])) {
    41                 $elements = array();
    42                 // Chaque élément est identifié soit par un délimiteur, soit par une regexp suivant la méthode configurée.
    43                 if ($parsing_config['element']['method'] == 'explode') {
    44                         // On récupére donc un tableau des éléments à lire en utilisant la fonction explode
    45                         $elements = explode($parsing_config['element']['delimiter'], $flux['page']);
    46                 } else {
    47                         // C'est une regexp... à compléter
    48                 }
     57        if (!empty($flux['page']) and ($sha_page = sha1($flux['page']))) {
     58                // On ne lit la page que si celle-ci a changé.
     59                include_spip('isocode_fonctions');
     60                if (!isocode_comparer_sha($sha_page, $table)) {
     61                        $elements = array();
     62                        // Chaque élément est identifié soit par un délimiteur, soit par une regexp suivant la méthode configurée.
     63                        if ($parsing_config['element']['method'] == 'explode') {
     64                                // On récupére donc un tableau des éléments à lire en utilisant la fonction explode
     65                                $elements = explode($parsing_config['element']['delimiter'], $flux['page']);
     66                        } else {
     67                                // C'est une regexp... à compléter TODO
     68                        }
    4969
    50                 // Initialisation d'un enregistrement vide (tous les champs sont des chaines ou des dates)
    51                 $empty_record = array();
    52                 foreach ($fields_config as $_cle => $_field) {
    53                         $empty_record[$_field] = '';
    54                 }
     70                        // Initialisation d'un enregistrement vide (tous les champs sont des chaines ou des dates)
     71                        $empty_record = array();
     72                        foreach ($fields_config as $_cle => $_field) {
     73                                $empty_record[$_field] = '';
     74                        }
    5575
    56                 // Chaque champ est identifié par une regexp qui permet d'extraire le nom du champ et sa valeur dans deux tableaux
    57                 // distincts indexés de façon concomittante.
    58                 // C'est pour l'instant la seule méthode permise sur un élément.
    59                 foreach ($elements as $_element) {
    60                         if (preg_match_all($parsing_config['field']['regexp'], $_element, $matches)) {
    61                                 $fields = $empty_record;
    62                                 $invalid_field = false;
    63                                 foreach ($matches[1] as $_cle => $_header) {
    64                                         if (isset($fields_config[trim($_header)])) {
    65                                                 $fields[$fields_config[trim($_header)]] = isset($matches[2][$_cle]) ? $matches[2][$_cle] : '';
    66                                         } else {
    67                                                 $invalid_field =true;
    68                                                 break;
     76                        // Chaque champ est identifié par une regexp qui permet d'extraire le nom du champ et sa valeur dans deux tableaux
     77                        // distincts indexés de façon concomittante.
     78                        // C'est pour l'instant la seule méthode permise sur un élément.
     79                        foreach ($elements as $_element) {
     80                                if (preg_match_all($parsing_config['field']['regexp'], $_element, $matches)) {
     81                                        $fields = $empty_record;
     82                                        $invalid_field = false;
     83                                        foreach ($matches[1] as $_cle => $_header) {
     84                                                if (isset($fields_config[trim($_header)])) {
     85                                                        $fields[$fields_config[trim($_header)]] = isset($matches[2][$_cle]) ? $matches[2][$_cle] : '';
     86                                                } else {
     87                                                        $invalid_field =true;
     88                                                        break;
     89                                                }
    6990                                        }
    70                                 }
    7191
    72                                 // Si on a pas détecté un champ invalide on peut finaliser l'élémént et l'enregistrer
    73                                 if (!$invalid_field) {
    74                                         // Si besoin on appelle une fonction pour chaque enregistrement afin de le compléter
    75                                         if (function_exists($f_complete_record)) {
    76                                                 $fields = $f_complete_record($fields);
     92                                        // Si on a pas détecté un champ invalide on peut finaliser l'élément et l'enregistrer
     93                                        if (!$invalid_field) {
     94                                                // Si besoin on appelle une fonction pour chaque enregistrement afin de le compléter
     95                                                if (function_exists($f_complete_record)) {
     96                                                        $fields = $f_complete_record($fields);
     97                                                }
     98                                                $records[] = $fields;
    7799                                        }
    78                                         $records[] = $fields;
    79100                                }
    80101                        }
     
    87108        }
    88109
    89         return array($records, $sha_file);
     110        return array($records, $sha_page);
    90111}
  • _plugins_/isocode/trunk/isocode_administrations.php

    r99228 r100264  
    11<?php
    22/**
    3  * Fichier gérant l'installation et la désinstallation du plugin Code de Langues
     3 * Fichier gérant l'installation et la désinstallation du plugin
    44 *
    55 * @package    SPIP\ISOCODE\ADMINISTRATION
  • _plugins_/isocode/trunk/isocode_fonctions.php

    r99231 r100264  
    2929 *      - index 0 : `true` si le vidage a réussi, `false` sinon.
    3030 *      - index 1 : liste des tables en erreur ou tableau vide sinon.
     31 *              - index 2 : liste des tables inchangées ou tableau vide sinon.
    3132 */
    3233function isocode_charger_tables($tables = array()) {
    3334
    34         $retour = array(true, array());
     35        $retour = array(true, array(), array());
    3536
    3637        // Suivant le tableau fourni en argument, on détermine la liste exacte des tables à charger.
     
    5758                foreach ($tables as $_table) {
    5859                        $erreur_table = false;
     60                        $sha_identique = false;
    5961
    6062                        // On détermine le service qui supporte le chargement de la table
    6163                        $service = isocode_trouver_service($_table);
    6264                        if ($service) {
    63                                 include_spip("services/${service}/${service}_api");
    6465                                // Détermination de la fonction de lecture de la table et lecture des données contenues
    6566                                // soit dans un fichier soit dans une page web.
     67                                // Si la table est déjà chargée et que le fichier ou la page source n'a pas changé, la fonction de
     68                                // lecture ne renvoie aucun élément pour éviter des traitements inutiles. Il faut donc distinguer
     69                                // ce cas d'une erreur de lecture.
     70                                include_spip("services/${service}/${service}_api");
    6671                                $lire_table = charger_fonction("isocode_read_{$GLOBALS['isocode'][$service]['tables'][$_table]['populating']}", 'inc');
    6772                                list($records, $sha) = $lire_table($service, $_table);
     
    8691                                        }
    8792                                } else {
     93                                        // Si le sha n'a pas changé la fonction de lecture renvoie aucun enregistrement mais ce n'est pas
     94                                        // une erreur à proprement parlé.
    8895                                        $erreur_table = true;
     96                                        if (isocode_comparer_sha($sha, $_table)) {
     97                                                $sha_identique = true;
     98                                        }
    8999                                }
    90100                        } else {
     
    94104                        if ($erreur_table) {
    95105                                $retour[0] = false;
    96                                 $retour[1][] = $_table;
     106                                if ($sha_identique) {
     107                                        $retour[2][] = $_table;
     108                                } else {
     109                                        $retour[1][] = $_table;
     110                                }
    97111                        }
    98112                }
     
    160174 * Si la table est vide ou invalide, la fonction renvoie une chaine vide.
    161175 *
     176 * @api
     177 *
    162178 * @param $table
    163179 *        Nom d'une table de codes ISO sans le préfixe `spip_`.
    164180 *
    165181 * @return string
    166  *              Nom du service permettant le chargement de la table.
     182 *              Nom du service permettant le chargement de la table ou chaine vide si aucun service n'est trouvé.
    167183 */
    168184function isocode_trouver_service($table) {
     
    197213 * La fonction lit les sous-répertoires du répertoire `services/` du plugin.
    198214 *
    199  * @return array
    200  *              La liste des services disponibles.
     215 * @api
     216 *
     217 * @return array
     218 *              La liste des services disponibles ou tableau vide aucun service n'est détecté.
    201219 */
    202220function isocode_lister_services() {
     
    216234/**
    217235 * Vérifie si le service demandé est fait bien partie de la liste des services disponibles.
     236 *
     237 * @api
    218238 *
    219239 * @param $service
     
    278298 * Informe sur la liste des tables déjà chagées en base de données.
    279299 * Les informations de la meta de chaque table sont complétées et renvoyées.
     300 *
     301 * @api
    280302 *
    281303 * @return array
     
    353375        // On récupère le sha de la table dans les metas si il existe (ie. la table a été chargée)
    354376        include_spip('inc/config');
    355         $sha_stocke = lire_config("isocode/tables/${table}/sha", '');
     377        $sha_stocke = lire_config("isocode/tables/${table}/sha", false);
    356378
    357379        if ($sha_stocke and ($sha == $sha_stocke)) {
  • _plugins_/isocode/trunk/lang/isocode_fr.php

    r99231 r100264  
    1010
    1111// E
    12         'erreur_charger_table' => 'Une erreur s\'est produite lors du chargement des tables @tables@',
    13         'erreur_vider_table' => 'Une erreur s\'est produite lors du vidage des tables @tables@',
     12        'erreur_charger_table' => 'Une erreur s\'est produite lors du chargement des tables @tables@.',
     13        'erreur_vider_table' => 'Une erreur s\'est produite lors du vidage des tables @tables@.',
    1414        'explication_action_table' => 'Si la table est déjà chargée en base de données elle sera vidée avant le chargement.',
    1515
     
    3737
    3838// N
     39        'notice_charger_table' => 'Aucune mise à jour n\'est nécessaire sur les tables @tables@.',
    3940        'notice_liste_aucune_table' => 'Aucune table de codes ISO n\'a encore été chargée en base de données. Utiliser le formulaire ci-dessous pour y remédier.',
    4041
    4142// S
    42         'succes_charger_table' => 'Les tables choisies ont bien été chargées',
    43         'succes_vider_table' => 'Les tables choisies ont bien été vidées',
     43        'succes_charger_table' => 'Les tables choisies ont bien été chargées.',
     44        'succes_vider_table' => 'Les tables choisies ont bien été vidées.',
    4445
    4546// T
Note: See TracChangeset for help on using the changeset viewer.