Changeset 99228 in spip-zone for _plugins_/isocode


Ignore:
Timestamp:
Aug 21, 2016, 8:33:37 AM (5 years ago)
Author:
eric@…
Message:

Mise au point du chargement et du déchargement de toutes les tables disponibles.
Refactoring du code dans la foulée.

Location:
_plugins_/isocode/trunk
Files:
4 added
8 edited
1 moved

Legend:

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

    r99066 r99228  
    3838function isocode_declarer_tables_principales($tables_principales) {
    3939
    40         // -------------------------------------------------
    41         // Table principale des codes ISO : spip_iso639codes
     40        // ---------------------------------------------------------------
     41        // Table principale des codes de langue ISO-639 : spip_iso639codes
    4242        $table_codes = array(
    4343                'code_639_3'  => "char(3) DEFAULT '' NOT NULL",      // The three-letter 639-3 identifier
     
    132132                array('field' => &$table_families, 'key' => &$table_families_key);
    133133
    134         // -------------------------------------------------
     134        // -------------------------------------------------------------------
    135135        // Table des indicatifs d'écritures (ISO 15924) : spip_iso15924scripts
    136136        $table_scripts = array(
     
    151151                array('field' => &$table_scripts, 'key' => &$table_scripts_key);
    152152
    153         // -------------------------------------------------
    154         // Table principale des codes ISO : spip_iso3166countries
     153        // --------------------------------------------------------------
     154        // Table des indicatifs des pays ISO-3166 : spip_iso3166countries
    155155        $table_countries = array(
    156156                'code_alpha2' => "char(2) DEFAULT '' NOT NULL",                  // The two-letter identifier
     
    177177                'date_ref'       => "datetime DEFAULT '0000-00-00 00:00:00' NOT NULL", // Subtag creation date
    178178                'no_script'      => "char(4) DEFAULT '' NOT NULL",     // The four letter script identifier not to be used for the subtag
     179                'scope'          => "varchar(32) DEFAULT '' NOT NULL", // Scope indication : collection, macrolanguage...
    179180                'macro_language' => "char(3) DEFAULT '' NOT NULL",     // Macrolanguage to which subtag is refering to
    180181                'deprecated'     => "datetime DEFAULT '0000-00-00 00:00:00' NOT NULL", // Deprecated date if any
  • _plugins_/isocode/trunk/formulaires/isocode_gerer_table.html

    r99073 r99228  
    1111                        <ul class="editer-groupe">
    1212                                [(#SAISIE{radio, action_table,
    13                                         explication=<:isocode:explication_action_table>,
    14                                         label=<:isocode:label_action_table>,
     13                                        explication=<:isocode:explication_action_table:>,
     14                                        label=<:isocode:label_action_table:>,
    1515                                        datas=#ENV{_actions_tables},
     16                                        defaut=#ENV{_action_defaut},
     17                                        disable=#ENV{_actions_disable},
    1618                                        obligatoire=oui,
    1719                                        info_obligatoire=''
    1820                                })]
    19                                 <li class="editer editer_xml obligatoire[(#ENV{erreurs}|table_valeur{xml}|oui) erreur]">
    20                                         <label><:plugonet:label_choisir_xml{dtd=plugin}:></label>
    21                                         <p class="explication"><:plugonet:info_choisir_pluginxml_generer:></p>
    22                                         [<span class="erreur_message">(#ENV{erreurs}|table_valeur{xml})</span>]
    23                                         <INCLURE{fond=formulaires/inc-checkbox_xml,
    24                                                 dossier=#EVAL{_DIR_RACINE},
    25                                                 regexp=plugin.xml$,
    26                                                 operation=generer,
    27                                                 message_nok_xml=<:plugonet:message_nok_aucun_xml{dtd=plugin}:>,
    28                                                 env} />
    29                                 </li>
     21                                [(#SAISIE{checkbox, tables,
     22                                        label=<:isocode:label_tables:>,
     23                                        datas=#ENV{_tables},
     24                                        obligatoire=oui,
     25                                        info_obligatoire=''
     26                                })]
    3027                        </ul>
    3128
  • _plugins_/isocode/trunk/formulaires/isocode_gerer_table.php

    r99073 r99228  
    1818 *              - `_actions_disable`    : (affichage) liste des actions désactivées (`vider` si aucune table n`est chargée)
    1919 *              - `_action_defaut`              : (affichage) action sélectionnée par défaut, `charger`
    20  *              - `_tables`                             : (affichage) noms des tables sans spip
     20 *              - `_tables`                             : (affichage) noms des tables sans le préfixe `spip_`
    2121 */
    2222function formulaires_isocode_gerer_table_charger() {
     
    3030        );
    3131
    32         // Acquérir la liste des tables par service et leur statut de chargement
     32        // Acquérir la liste des tables et leur statut de chargement
    3333        $tables = isocode_lister_tables();
     34        $aucune_table_charge = true;
     35        if ($tables) {
     36                foreach ($tables as $_table) {
     37                        $valeurs['_tables'][$_table] = "<em>${_table}</em>, " . _T("isocode:label_table_${_table}");
     38                        if (isocode_table_chargee($_table, $meta_regne)) {
     39                                $valeurs['_tables'][$_table] .= ' - [' . _T('isocode:info_table_chargee') . ']';
     40                                $aucune_table_charge = false;
     41                        }
     42                }
     43        }
    3444
    3545        // Désactiver l'action vider si aucun table n'est chargée
     46        if ($aucune_table_charge) {
     47                $valeurs['_actions_disable'] = array('vider' => 'oui');
     48                $valeurs['_action_defaut'] = 'charger';
     49        }
    3650
    3751        return $valeurs;
     
    5872
    5973/**
    60  * Exécution du formulaire : le règne choisi est soit vidé, soit chargé jusqu'au rang minimal
    61  * choisi en y intégrant les traductions des noms communs sélectionnées.
     74 * Exécution du formulaire : les tables choisies sont soit vidées, soit chargées.
    6275 *
    63  * @uses taxonomie_regne_existe()
    64  * @uses taxonomie_vider_regne()
    65  * @uses taxonomie_charger_regne()
     76 * @uses isocode_charger_tables()
     77 * @uses isocode_decharger_tables()
    6678 *
    6779 * @return array
     
    7082 */
    7183function formulaires_isocode_gerer_table_traiter() {
     84
    7285        $retour = array();
    7386
     87        // Acquisition des saisies: comme elles sont obligatoires, il existe toujours une action et une
     88        // table.
    7489        $action = _request('action_table');
    75         $regne = _request('tables');
     90        $tables = _request('tables');
    7691
    77         $ok = true;
    78         $item = '';
    79         $table_existe = true;
     92        // Pour chaque table, on génère l'action demandée
    8093        if ($action == 'vider') {
    81                 if ($table_existe) {
    82 //                      $ok = taxonomie_vider_regne($regne);
    83 //                      $item = $ok ? 'isocode:succes_vider_table' : 'isocode:erreur_vider_table';
    84                 }
    85                 else {
    86                         // Inutile de vider un règne non encore chargé
    87                         $ok = false;
    88                         $item = 'isocode:notice_vider_table_non_chargee';
    89                 }
     94                list($action_ok, $tables_nok) = isocode_decharger_tables($tables);
     95                $message = $action_ok
     96                        ? _T('isocode:succes_vider_table')
     97                        : _T('isocode:erreur_vider_table', array('tables' => implode(', ', $tables_nok)));
    9098        }
    9199        else {
    92                 // La fonction de chargement du règne lance un vidage préalable si le règne
    93                 // demandé est déjà chargé. Un mécanisme de sauvegarde interne permet aussi de
    94                 // restituer les modifications manuelles des taxons
    95 //              $ok = taxonomie_charger_regne($regne, $rang_feuille, $langues);
    96                 $item = $ok ? 'isocode:succes_charger_table' : 'isocode:erreur_charger_table';
     100                // La fonction de chargement de la table lance un vidage préalable si la table
     101                // 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)));
    97106        }
    98107
    99         $message = $ok ? 'message_ok' : 'message_erreur';
    100         $retour[$message] = _T($item);
     108        $type_message = $action_ok ? 'message_ok' : 'message_erreur';
     109        $retour[$type_message] = $message;
    101110        $retour['editable'] = true;
    102111
    103112        return $retour;
    104113}
    105 
    106 ?>
  • _plugins_/isocode/trunk/inc/isocode_read_file_csv.php

    r99227 r99228  
    1111
    1212/**
    13  * Compare le sha passé en argument pour la table concernée avec le sha stocké dans la meta
    14  * pour cette même table.
    15  *
    16  * @api
    17  *
    18  * @param string $sha
    19  * @param string $table
    20  *
    21  * @return bool
    22  */
    23 function isocode_comparer_sha($sha, $table) {
    24 
    25         $sha_identique = false;
    26 
    27         // On récupère le sha de la table dans les metas si il existe (ie. la table a été chargée)
    28         include_spip('inc/config');
    29         $sha_stocke = lire_config("isocode/tables/${table}/sha", '');
    30 
    31         if ($sha_stocke and ($sha == $sha_stocke)) {
    32                 $sha_identique = true;
    33         }
    34 
    35         return $sha_identique;
    36 }
    37 
    38 
    39 /**
    4013 * @param string $service
    4114 * @param string $table
     
    4518 * @return array
    4619 */
    47 function isocode_read_file_csv($service, $table) {
     20function inc_isocode_read_file_csv($service, $table) {
    4821
    4922        // Initialisations
     
    9871        return array($records, $sha_file);
    9972}
    100 
    101 
    102 /**
    103  * @param string $service
    104  * @param string $table
    105  * @param string $url
    106  * @param string $record_delimiter
    107  * @param string $field_regexp
    108  * @param array  $fields_config
    109  *
    110  * @return array
    111  */
    112 function isocode_read_page_text($service, $table) {
    113 
    114         // Initialisations
    115         $records = array();
    116         $sha_file = false;
    117         $f_complete_record = "${table}_complete_by_record";
    118         $f_complete_table = "${table}_complete_by_table";
    119 
    120         // Inclusion des configurations et des fonctions spécifiques au service qui fournit les données
    121         // de la table à remplir.
    122         include_spip("services/${service}/${service}_api");
    123 
    124         // Initialisations des données de configuration propre au service et à la table
    125         $url = $GLOBALS['isocode'][$service]['tables'][$table]['url'];
    126         $parsing_config = $GLOBALS['isocode'][$service]['tables'][$table]['parsing'];
    127         $fields_config = $GLOBALS['isocode'][$service]['tables'][$table]['basic_fields'];
    128 
    129         // Acquisition de la page sur le site de l'IANA
    130         include_spip('inc/distant');
    131         $options = array();
    132         $flux = recuperer_url($url, $options);
    133 
    134         if (!empty($flux['page'])) {
    135                 $elements = array();
    136                 // Chaque élément est identifié soit par un délimiteur, soit par une regexp suivant la méthode configurée.
    137                 if ($parsing_config['element']['method'] == 'explode') {
    138                         // On récupére donc un tableau des éléments à lire en utilisant la fonction explode
    139                         $elements = explode($parsing_config['element']['delimiter'], $flux['page']);
    140                 } else {
    141                 }
    142 
    143                 // Chaque champ est identifié par une regexp qui permet d'extraire le nom du champ et sa valeur dans deux tableaux
    144                 // distincts indexés de façon concomittante.
    145                 // C'est pour l'instant la seule méthode permise sur un élément.
    146                 foreach ($elements as $_element) {
    147                         if (preg_match_all($_element, $parsing_config['fields']['regexp'], $matches)) {
    148                                 $fields = array();
    149                                 foreach ($matches[1] as $_cle => $_header) {
    150                                         $fields[$fields_config[trim($_header)]] = isset($matches[2][$_cle]) ? $matches[2][$_cle] : '';
    151                                 }
    152                                 // Si besoin on appelle une fonction pour chaque enregistrement afin de le compléter
    153                                 if (function_exists($f_complete_record)) {
    154                                         $fields = $f_complete_record($fields);
    155                                 }
    156                                 $records[] = $fields;
    157                         }
    158                 }
    159 
    160                 // Si besoin on appelle une fonction pour toute la table
    161                 if (function_exists($f_complete_table)) {
    162                         $records = $f_complete_table($records);
    163                 }
    164         }
    165 
    166         return array($records, $sha_file);
    167 }
  • _plugins_/isocode/trunk/isocode_administrations.php

    r99066 r99228  
    2626//      $config_defaut = configurer_isocode();
    2727
     28        // Liste des tables créées par le plugin
     29        include_spip('isocode_fonctions');
     30        $tables = array();
     31        foreach (isocode_lister_tables() as $_table) {
     32                $tables[] = "spip_${_table}";
     33        }
     34
    2835        $maj['create'] = array(
    2936                array(
    3037                        'maj_tables',
    31                         array(
    32                                 'spip_iso639codes',
    33                                 'spip_iso639names',
    34                                 'spip_iso639macros',
    35                                 'spip_iso639retirements',
    36                                 'spip_iso639families',
    37                                 'spip_iso15924scripts',
    38                                 'spip_iso3166countries',
    39                                 'spip_iana5646subtags'
    40                         )
     38                        $tables
    4139                ),
    4240                //              array('ecrire_config', 'isocode', $config_defaut)
     
    4846        // Ajout systématique des données iso dans la base de données, quelque soit l'action en cours.
    4947        // Ces données n'étant pas modifiables, il n'y a pas de risque à recharger ces tables.
    50         include_spip('isocode_fonctions');
    5148//      isocode_charger_tables();
    5249}
     
    6360function isocode_vider_tables($nom_meta_base_version) {
    6461
     62        // Liste des tables créées par le plugin
     63        include_spip('isocode_fonctions');
     64        $tables = isocode_lister_tables();
     65
    6566        // Supprimer les tables ISO créées par le plugin
    66         sql_drop_table('spip_iso639codes');
    67         sql_drop_table('spip_iso639names');
    68         sql_drop_table('spip_iso639macros');
    69         sql_drop_table('spip_iso639retirements');
    70         sql_drop_table('spip_iso639families');
    71         sql_drop_table('spip_iso15924scripts');
    72         sql_drop_table('spip_iso3166countries');
    73         sql_drop_table('spip_iana5646subtags');
     67        foreach ($tables as $_table) {
     68                sql_drop_table("spip_${_table}");
     69        }
    7470
    7571        // Effacer la meta de configuration et de stockage du plugin
  • _plugins_/isocode/trunk/isocode_fonctions.php

    r99066 r99228  
    1111
    1212/**
    13  * Charge tout ou partie des tables de codes ISO dans la base de données.
    14  * Les tables sont regroupées par service.
     13 * Charge en base de données une liste de tables de codes ISO donnée.
     14 * Si la liste est vide, la fonction charge toutes les tables disponibles.
    1515 *
    1616 * @api
    1717 * @filtre
    18  * @uses iso_read_table()
    19  * @uses iana_read_table()
    20  *
    21  * @param array $tables
    22  *      Tableau, par service, des tables à charger. Si le tableau est vide ou si la liste des tables
    23  *      d'un service donné est vide, l'ensemble des tables du ou des services concernés seront chargées.
     18 *
     19 * @uses isocode_trouver_service()
     20 * @uses isocode_decharger_tables()
     21 *
     22 * @param array $tables
     23 *      Liste des tables à charger. Si le tableau est vide l'ensemble des tables
     24 *      seront chargées.
    2425 *      Les tables doivent être libellées sans le préfixe `spip_`.
    25  *              Les services disponibles actuellement sont `iso` et `iana`.
    26  *
    27 * @return bool
    28  *        `true` si le chargement a réussi, `false` sinon
     26 *
     27 * @return array
     28 *      Tableau résultat de l'action de vidage:
     29 *      - index 0 : `true` si le vidage a réussi, `false` sinon.
     30 *      - index 1 : liste des tables en erreur ou tableau vide sinon.
    2931 */
    3032function isocode_charger_tables($tables = array()) {
    3133
    32         $retour = true;
     34        $retour = array(true, array());
    3335
    3436        // Suivant le tableau fourni en argument, on détermine la liste exacte des tables à charger.
     
    3739        if (!$tables) {
    3840                // Le tableau est vide : il faut charger toutes les tables de tous les services supportés.
    39                 $tables_a_charger = isocode_lister_tables();
     41                $tables = isocode_lister_tables();
    4042        } elseif (is_string($tables)) {
    4143                // L'argument n'est pas un tableau mais une chaine, on considère que l'appelant a demandé
    42                 // le chargement de toutes les tables du service identifié par cette chaine.
    43                 $tables_a_charger = isocode_lister_tables($tables);
    44         } elseif (is_array($tables)) {
    45                 $cles = array_keys($tables);
    46                 if (is_numeric($cles[0])) {
    47                         // On traite le cas où le tableau est de la forme ('iso', 'iana')
    48                         // au lieu de ('iso' => array(...), 'iana' => array(...)).
    49                         $tables_a_charger = isocode_lister_tables($tables);
    50                 } else {
    51                         $tables_a_charger = $tables;
    52                 }
    53         } else {
    54                 $tables_a_charger = array();
    55         }
    56 
    57         // On charge, service par service, chacune des tables spécifiées pour chaque service concerné.
     44                // le chargement d'une table identifiée par cette chaine.
     45                $tables = array($tables);
     46        } elseif (!is_array($tables)) {
     47                $tables = array();
     48        }
     49
     50        // On charge chacune des tables spécifiées en identifiant au préalable le service concerné.
    5851        // -- Pour éviter d'avoir une mise à jour bancale, il faudrait inclure les requêtes SQL dans
    5952        // une transaction ce qui n'est pas possible avec spip aujourd'hui.
    6053        // De fait, on ne peut pas assurer que si une erreur se produit le résultat soit cohérent et
    6154        // on renvoie juste l'erreur --
    62         if ($tables_a_charger) {
     55        if ($tables) {
    6356                include_spip('inc/config');
    64                 include_spip('inc/isocode_outils');
    65                 foreach ($tables_a_charger as $_service => $_tables) {
    66                         // Si le service est bien disponible on charge les tables concernées.
    67                         if (isocode_service_disponible($_service)) {
    68                                 // Vérification et finalisation de la liste des tables à charger
    69                                 if (!$_tables) {
    70                                         // La liste des tables est vide : il faut charger toutes les tables du service concerné.
    71                                         $_tables = isocode_lister_tables($_service);
    72                                 } elseif (is_string($_tables)) {
    73                                         // La liste des tables n'est pas un tableau mais une chaine, on considère la chaine est
    74                                         // le nom de table à charger.
    75                                         $_tables = array($_tables);
    76                                 } elseif (!is_array($_tables)) {
    77                                         // La liste des tables n'est ni une chaine ni un tableau : c'est une erreur.
    78                                         $_tables = array();
     57                foreach ($tables as $_table) {
     58                        $erreur_table = false;
     59
     60                        // On détermine le service qui supporte le chargement de la table
     61                        $service = isocode_trouver_service($_table);
     62                        if ($service) {
     63                                include_spip("services/${service}/${service}_api");
     64                                // Détermination de la fonction de lecture de la table et lecture des données contenues
     65                                // soit dans un fichier soit dans une page web.
     66                                $lire_table = charger_fonction("isocode_read_{$GLOBALS['isocode'][$service]['tables'][$_table]['populating']}", 'inc');
     67                                list($records, $sha) = $lire_table($service, $_table);
     68                                if ($records) {
     69                                        // Suppression des éléments éventuels déjà chargés. On ne gère pas d'erreur
     70                                        // sur ce traitement car elle sera forcément détectée sur l'insert qui suit.
     71                                        isocode_decharger_tables($_table);
     72
     73                                        // Insertion dans la base de données des éléments extraits
     74                                        $sql_ok = sql_insertq_multi("spip_${_table}", $records);
     75                                        if ($sql_ok !== false) {
     76                                                // On stocke les informations de chargement de la table dans une meta.
     77                                                $meta = array(
     78                                                        'service' => $service,
     79                                                        'sha'     => $sha,
     80                                                        'nbr'     => count($records),
     81                                                        'maj'     => date('Y-m-d H:i:s')
     82                                                );
     83                                                ecrire_config("isocode/tables/${_table}", $meta);
     84                                        } else {
     85                                                $erreur_table = true;
     86                                        }
     87                                } else {
     88                                        $erreur_table = true;
    7989                                }
    80 
    81                                 if ($_tables) {
    82                                         include_spip("services/${_service}/${_service}_api");
    83                                         foreach ($_tables as $_table) {
    84                                                 // Détermination de la fonction de lecture de la table et lecture des données contenues
    85                                                 // soit dans un fichier soit dans une page web.
    86                                                 $lire_table = "isocode_read_{$GLOBALS['isocode'][$_service]['tables'][$_table]['populating']}";
    87                                                 list($records, $sha) = $lire_table($_service, $_table);
    88                                                 if ($records) {
    89                                                         // Suppression des éléments éventuels déjà chargés.
    90                                                         sql_delete("spip_${_table}");
    91 
    92                                                         // Insertion dans la base de données des éléments extraits
    93                                                         sql_insertq_multi("spip_${_table}", $records);
    94                                                         // On stocke les informations de chargement de la table dans une meta.
    95                                                         $meta = array(
    96                                                                 'sha' => $sha,
    97                                                                 'nbr' => count($records),
    98                                                                 'maj' => date('Y-m-d H:i:s'));
    99                                                         ecrire_config("isocode/tables/${_table}", $meta);
    100                                                 }
    101                                         }
    102                                 }
     90                        } else {
     91                                $erreur_table = true;
     92                        }
     93
     94                        if ($erreur_table) {
     95                                $retour[0] = false;
     96                                $retour[1][] = $_table;
    10397                        }
    10498                }
     
    109103
    110104
     105/**
     106 * Supprime en base de données, le contenu des tables de codes ISO choisies.
     107 * Si la liste des tables est vide la fonction considère que toutes les tables doivent être vidées.
     108 * La meta concernant les informations de chargement de chaque table est aussi effacée.
     109 *
     110 * @api
     111 * @filtre
     112 *
     113 * @param array $tables
     114 *        Liste des noms de table sans le préfixe `spip_`.
     115 *
     116 * @return array
     117 *         Tableau résultat de l'action de vidage:
     118 *         - index 0 : `true` si le vidage a réussi, `false` sinon.
     119 *         - index 1 : liste des tables en erreur ou tableau vide sinon.
     120 */
     121function isocode_decharger_tables($tables = array()) {
     122
     123        $retour = array(true, array());
     124
     125        // Suivant le tableau fourni en argument, on détermine la liste exacte des tables à charger.
     126        // Le cas où le service existe mais que la liste de tables associées est vide est traité dans
     127        // la boucle des services ci-après.
     128        if (!$tables) {
     129                // Le tableau est vide : il faut charger toutes les tables de tous les services supportés.
     130                $tables = isocode_lister_tables();
     131        } elseif (is_string($tables)) {
     132                // L'argument n'est pas un tableau mais une chaine, on considère que l'appelant a demandé
     133                // le chargement d'une table identifiée par cette chaine.
     134                $tables = array($tables);
     135        } elseif (!is_array($tables)) {
     136                $tables = array();
     137        }
     138
     139        // On boucle sur la liste des tables et on vide chaque table référencée.
     140        if ($tables) {
     141                foreach ($tables as $_table) {
     142                        $sql_ok = sql_delete("spip_${_table}");
     143                        if ($sql_ok !== false) {
     144                                // Supprimer la meta propre au règne.
     145                                effacer_meta("isocode/tables/${_table}");
     146                        } else {
     147                                $retour[0] = false;
     148                                $retour[1][] = $_table;
     149                        }
     150                }
     151        }
     152
     153        return $retour;
     154}
     155
     156
     157/**
     158 * Détermine le service associé au chargement de la table de codes ISO choisie.
     159 * Si la table est vide ou invalide, la fonction renvoie une chaine vide.
     160 *
     161 * @param $table
     162 *        Nom d'une table de codes ISO sans le préfixe `spip_`.
     163 *
     164 * @return string
     165 *              Nom du service permettant le chargement de la table.
     166 */
     167function isocode_trouver_service($table) {
     168
     169        static $services = array();
     170        static $tables = array();
     171        $service = '';
     172
     173        if (is_string($table) and $table) {
     174                if (!$services) {
     175                        $services = isocode_lister_services();
     176                }
     177
     178                foreach ($services as $_service) {
     179                        if (!isset($tables[$_service])) {
     180                                include_spip("services/${_service}/${_service}_api");
     181                                $tables[$_service] = array_keys($GLOBALS['isocode'][$_service]['tables']);
     182                        }
     183                        if (in_array(strtolower($table), $tables[$_service])) {
     184                                $service = $_service;
     185                                break;
     186                        }
     187                }
     188        }
     189
     190        return $service;
     191}
     192
     193
     194/**
     195 * Retourne la liste des services disponibles pour le chargement des tables de codes ISO.
     196 * La fonction lit les sous-répertoires du répertoire `services/` du plugin.
     197 *
     198 * @return array
     199 *              La liste des services disponibles.
     200 */
    111201function isocode_lister_services() {
    112202
     
    123213
    124214
     215/**
     216 * Vérifie si le service demandé est fait bien partie de la liste des services disponibles.
     217 *
     218 * @param $service
     219 *              Nom du service à vérifier.
     220 *
     221 * @return bool
     222 *      `true` si le service est disponible, `false` sinon.
     223 */
    125224function isocode_service_disponible($service) {
    126225
    127         $autorisation = false;
     226        $disponible = false;
    128227        if ($service and in_array(strtolower($service), isocode_lister_services())) {
    129                 $autorisation = true;
    130         }
    131 
    132         return $autorisation;
    133 }
    134 
    135 
     228                $disponible = true;
     229        }
     230
     231        return $disponible;
     232}
     233
     234
     235/**
     236 * Retourne la liste de toutes les tables ou celle associée à un ou plusieurs services donnés.
     237 *
     238 * @param array $services
     239 *              Liste des services pour lesquels la liste des tables associées est demandée.
     240 *              Si la liste est vide la fonction renvoie les tables de tous les services dsponibles.
     241 *
     242 * @return array
     243 *              Liste des tables de codes ISO sans le préfixe `spip_`.
     244 */
    136245function isocode_lister_tables($services = array()) {
    137246
     
    156265                if (isocode_service_disponible($_service)) {
    157266                        include_spip("services/${_service}/${_service}_api");
    158                         $tables[$_service] = array_keys($GLOBALS['isocode'][$_service]['tables']);
     267                        $tables = array_merge($tables, array_keys($GLOBALS['isocode'][$_service]['tables']));
    159268                }
    160269        }
     
    164273
    165274
    166 function isocode_verifier_codes_spip() {
    167 
    168         $codes_verifies = array();
    169        
    170         include_spip('inc/lang_liste');
    171         if ($GLOBALS['codes_langues']) {
    172                 foreach ($GLOBALS['codes_langues'] as $_code => $_nom) {
    173                         $from = array('spip_iso639codes');
    174                         $select = array('*');
    175                         if (strlen($_code) == 2) {
    176                                 // Si le code a une taille de 2 caractères on recherche de suite dans la table iso639codes
    177                                 // un élément dont le code ISO639-1 est égal.
    178                                 $where = array('code_639_1=' . sql_quote($_code));
    179                                 $codes_iso = sql_allfetsel($select, $from, $where);
    180                                 if ($codes_iso) {
    181                                         $codes_verifies['ok']['iso6391'][$_code] = $codes_iso;
    182                                 } else {
    183                                         $codes_verifies['nok']['iso6391'][$_code] = array('nom_spip' => $_nom);
    184                                 }
    185                         } elseif (strlen($_code) == 3) {
    186                                 // Si le code a une taille de 3 caractères on recherche :
    187                                 // - dans la table iso639codes un élément dont le code ISO639-3 est égal.
    188                                 // - et sinon dans la table iso639families un élément dont le code ISO639-5 est égal.
    189                                 $where = array('code_639_3=' . sql_quote($_code));
    190                                 $codes_iso = sql_allfetsel($select, $from, $where);
    191                                 if ($codes_iso) {
    192                                         $codes_verifies['ok']['iso6393'][$_code] = $codes_iso;
    193                                 } else {
    194                                         $where = array('code_639_5=' . sql_quote($_code));
    195                                         $code_famille = sql_fetsel($select, array('spip_iso639families'), $where);
    196                                         if ($code_famille) {
    197                                                 $codes_verifies['ok']['iso6395'][$_code] = array('nom_spip' => $_nom);
    198                                         } else {
    199                                                 $codes_verifies['nok']['iso6393'][$_code] = array('nom_spip' => $_nom);
    200                                         }
    201                                 }
    202                         } else {
    203                                 $codes_verifies['nok']['spip'][$_code] = array('nom_spip' => $_nom);
    204                         }
    205                 }
    206         }
    207 
    208         return $codes_verifies;
    209 }
    210 
    211 function isocode_verifier_iso639_5() {
    212 
    213         $codes_verifies = array();
    214 
    215         $codes_639_5 = sql_allfetsel('*', 'spip_iso639families');
    216         if ($codes_639_5) {
    217                 foreach($codes_639_5 as $_code) {
    218                         if (sql_countsel('spip_iso639macros', 'code_639_3=' . sql_quote($_code['code_639_5']))) {
    219                                 $codes_verifies['ok'][] = $_code['code_639_5'];
    220                         } else {
    221                                 $codes_verifies['nok'][] = $_code['code_639_5'];
    222                         }
    223                 }
    224         }
    225 
    226         return $codes_verifies;
    227 }
     275/**
     276 * Indique si une table de codes ISO est déjà chargée ou pas en base de données.
     277 * La fonction scrute la table `spip_${table}` et non la meta propre à la table.
     278 *
     279 * @api
     280 * @filtre
     281 *
     282 * @param string $table
     283 *        Nom de la table sans le préfixe `spip_`.
     284 * @param array  $meta_table
     285 *        Meta propre à la table, créée lors du chargement de celle-ci et retournée si la table
     286 *        est déjà chargée.
     287 *
     288 * @return bool
     289 *        `true` si la table est chargée, `false` sinon.
     290 */
     291function isocode_table_chargee($table, &$meta_table) {
     292        $meta_table = array();
     293        $table_chargee = false;
     294
     295        $retour = sql_countsel("spip_${table}");
     296        if ($retour) {
     297                // Récupérer la meta propre au règne afin de la retourner.
     298                include_spip('inc/config');
     299                $meta_table = lire_config("isocode/tables/${table}");
     300                $table_chargee = true;
     301        }
     302
     303        return $table_chargee;
     304}
     305
     306
     307/**
     308 * Compare le sha passé en argument pour la table concernée avec le sha stocké dans la meta
     309 * pour cette même table.
     310 *
     311 * @api
     312 *
     313 * @param string $sha
     314 *              Sha à comparer à celui de la table.
     315 * @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.
     318 *
     319 * @return bool
     320 *      `true` si le sha passé en argument est identique au sha stocké pour la table choisie, `false` sinon.
     321 */
     322function isocode_comparer_sha($sha, $table) {
     323
     324        $sha_identique = false;
     325
     326        // On récupère le sha de la table dans les metas si il existe (ie. la table a été chargée)
     327        include_spip('inc/config');
     328        $sha_stocke = lire_config("isocode/tables/${table}/sha", '');
     329
     330        if ($sha_stocke and ($sha == $sha_stocke)) {
     331                $sha_identique = true;
     332        }
     333
     334        return $sha_identique;
     335}
  • _plugins_/isocode/trunk/lang/isocode_fr.php

    r99073 r99228  
    11<?php
    22// This is a SPIP language file  --  Ceci est un fichier langue de SPIP
    3 // Fichier source, a modifier dans svn://zone.spip.org/spip-zone/_plugins_/plugonet/trunk/lang/
    4 if (!defined('_ECRIRE_INC_VERSION')) {
    5         return;
    6 }
     3
     4if (!defined('_ECRIRE_INC_VERSION')) return;
    75
    86$GLOBALS[$GLOBALS['idx_lang']] = array(
    97
    10         // B
     8// B
    119        'bouton_isocode' => 'Codes ISO',
    1210
    13         // O
    14         'onglet_generer' => 'Générer paquet.xml',
    15         'onglet_valider' => 'Valider paquet.xml',
    16         'onglet_verifier' => 'Vérifier plugin.xml',
     11// 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@',
     14        'explication_action_table' => 'Si la table est déjà chargée en base de données elle sera vidée avant le chargement.',
    1715
    18         // R
     16// I
     17        'info_table_chargee' => 'chargée',
    1918
    20         // T
     19// L
     20        'label_action_charger_table' => 'Charger une table',
     21        'label_action_table' => 'Action à exécuter',
     22        'label_action_vider_table' => 'Vider une table',
     23        'label_table_iana5646subtags' => 'table reproduisant le registre IANA des sous-étiquettes de langues (RFC 5646)',
     24        'label_table_iso15924scripts' => 'table des indicatifs d\'écritures (ISO 15924)',
     25        'label_table_iso3166countries' => 'table des indicatifs des pays (ISO-3166)',
     26        'label_table_iso639codes' => 'table principale des codes de langue (ISO-639-1,2 et 3)',
     27        'label_table_iso639families' => 'table des familles et groupes de langues (ISO-639-5)',
     28        'label_table_iso639macros' => 'table des macrolangues',
     29        'label_table_iso639names' => 'table des noms de langues',
     30        'label_table_iso639retirements' => 'table des langues supprimées',
     31        'label_tables' => 'Tables sur lesquelles appliquer l\'action',
     32
     33// N
     34        'notice_liste_aucune_table' => '<LANGONET_DEFINITION_MANQUANTE>',
     35
     36// S
     37        'succes_charger_table' => 'Les tables choisies ont bien été chargées',
     38        'succes_vider_table' => 'Les tables choisies ont bien été vidées',
     39
     40// T
    2141        'titre_form_gerer_table' => 'Vider ou charger des tables',
     42        'titre_liste_tables' => 'Liste des tables chargées en base de données',
    2243        'titre_page' => 'Gestion des tables de codes ISO',
    2344);
  • _plugins_/isocode/trunk/paquet.xml

    r99073 r99228  
    22        prefix="isocode"
    33        categorie="outil"
    4         version="0.1.0"
     4        version="0.1.1"
    55        etat="dev"
    66        compatibilite="[3.1.0;3.2.*]"
  • _plugins_/isocode/trunk/services/iana/iana_api.php

    r99066 r99228  
    1515                        'Type'            => 'type',
    1616                        'Subtag'          => 'subtag',
     17                        'Tag'             => 'subtag',
    1718                        'Description'     => 'description',
    1819                        'Added'               => 'date_ref',
     
    3435                        'field'        => array(
    3536                                'method'    => 'regexp',
    36                                 'regexp'    => '%(\w+):\s+(.*)%i'
     37                                'regexp'    => '%^([a-z]+-*[a-z]*):\s+(.*)%im'
    3738                        )
    3839                )
Note: See TracChangeset for help on using the changeset viewer.