Changeset 114173 in spip-zone


Ignore:
Timestamp:
Feb 27, 2019, 7:59:20 PM (6 months ago)
Author:
eric@…
Message:

Mise au point du formulaire d'import.
Il ne reste plus qu'à finaliser la fonction d'import.

Location:
_plugins_/taxonomie/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/taxonomie/trunk/lang/taxonomie_fr.php

    r114150 r114173  
    6767        'import_configuration_labelcase' => 'Remplacer la configuration actuelle du plugin Taxonomie par celle du fichier d’import',
    6868
    69         'import_taxons_edites_ajouter' => 'Intégrer les modifications de taxons du fichier d’import dans les taxons du site sans écraser les éventuelles modifications existantes.',
    70         'import_taxons_edites_explication' => 'Il existe dans le site des taxons du règne au genre dont certains champs ont été modifiés.',
    71         'import_taxons_edites_avertissement1' => 'Il n\'existe  pas dans le site de taxons du règne au genre modifiés.',
    72         'import_taxons_edites_fusionner' => 'Intégrer les modifications de taxons du fichier d’import dans les taxons du site sans tenir compte de l\'existant.',
    73         'import_taxons_edites_label' => 'Les taxons du règne au genre édités',
    74         'import_especes_ajouter' => 'Ajouter les espèces du fichier d’import. Les espèces disponibles sur le site ne seront pas modifiées.',
    75         'import_especes_explication' => 'Il existe déjà des espèces dans le site.',
    76         'import_especes_fusionner' => 'Ajouter les espèces du fichier d’import et remplacer les espèces du site aussi disponibles dans le fichier d’import.',
     69        'import_taxons_edites_ajouter' => 'Importer uniquement les données des taxons du fichier d’import qui ne correspondent à aucun taxon modifié de la base',
     70        'import_taxons_edites_explication' => 'Il existe, dans la base du site, des taxons du règne au genre dont certains champs ont déjà été modifiés manuellement.',
     71        'import_taxons_edites_avertissement' => 'La base du site ne contient aucun taxon du règne au genre modifié manuellement.',
     72        'import_taxons_edites_fusionner' => 'Importer toutes les données des taxons du fichier d\'import',
     73        'import_taxons_edites_label' => 'Les taxons du règne au genre modifiés manuellement',
     74        'import_especes_ajouter' => 'Importer uniquement les espèces du fichier d’import qui n\'existent pas encore dans la base',
     75        'import_especes_explication' => 'Il existe déjà des espèces dans la base du site.',
     76        'import_especes_avertissement' => 'La base du site ne contient aucune espèce.',
     77        'import_especes_fusionner' => 'Importer toutes les espèces du fichier d’import',
    7778        'import_especes_label' => 'Les espèces et descendants',
    78         'import_regne_avertissement' => 'Aucun règne n\'est encore chargé dans le site. Il n\est donc pas possible d\'importer des données. Veuillez charger au moins un règne avant de faire une importation de taxons.',
    79 
     79        'import_regne_avertissement' => 'Aucun règne n\'est encore chargé dans le site. Il n\'est donc pas possible d\'importer des données. Veuillez charger au moins un règne avant de faire une importation de taxons.',
    8080
    8181        'info_boite_taxonomie_configuration' => 'Cette page permet de configurer les paramètres de base du plugin comme la liste des langues utilisables pour nommer ou décrire les taxons.',
  • _plugins_/taxonomie/trunk/taxonomie_ieconfig.php

    r113820 r114173  
    5656                $texte_explication = _T(
    5757                        'taxonomie:import_resume',
    58                         array('version' => $import['version'], 'schema' => $import['schema']));
     58                        array('version' => $import['version'], 'schema' => $import['schema'])
     59                );
    5960
    6061                // La configuration : une case suffit car on applique toujours un remplacement et la configuration est
     
    102103                        ),
    103104                );
     105
     106                // On détermine les règnes existant dans le site: si un règne n'est pas présent sur le site
     107                // aucun import n'est possible.
     108                include_spip('taxonomie_fonctions');
     109                $regnes = regne_repertorier();
     110                if ($regnes) {
     111                        // Pour chaque règne présent dans le fichier on crée la même liste de saisies instanciées pour le règne.
     112                        foreach ($import['contenu']['regnes'] as $_regne) {
     113                                // Titre du règne qui sert de séparation dans le formulaire.
     114                                if (($import['contenu'][$_regne]['taxons']['edites'])
     115                                or ($import['contenu'][$_regne]['especes'])) {
     116                                        $explication = ucfirst(_T("taxonomie:regne_${_regne}"));
     117                                        $saisies[0]['saisies'][] = array(
     118                                                'saisie'  => 'explication',
     119                                                'options' => array(
     120                                                        'nom'   => "${_regne}_import_regne",
     121                                                        'texte' => $explication,
     122                                                ),
     123                                        );
     124                                }
     125
     126                                // Taxons importés et édités (du règne au genre).
     127                                $data = array();
     128                                if ($import['contenu'][$_regne]['taxons']['edites']) {
     129                                        $data['fusionner'] = _T('taxonomie:import_taxons_edites_fusionner');
     130                                        // Identifier si le site contient déjà des taxons édités et décider de l'avertissement
     131                                        // nécessaire et des options.
     132                                        $taxons_modifies = taxon_preserver($_regne);
     133                                        if (!empty($taxons_modifies['edites'])) {
     134                                                $explication = _T('taxonomie:import_taxons_edites_explication');
     135                                                $data['ajouter'] = _T('taxonomie:import_taxons_edites_ajouter');
     136                                        } else {
     137                                                $explication = _T('taxonomie:import_taxons_edites_avertissement');
     138                                        }
     139                                        $saisies[0]['saisies'][] = array(
     140                                                'saisie'  => 'radio',
     141                                                'options' => array(
     142                                                        'nom'         => "${_regne}_import_edites",
     143                                                        'label'       => '<:taxonomie:import_taxons_edites_label:>',
     144                                                        'explication' => $explication,
     145                                                        'datas'       => $data,
     146                                                ),
     147                                        );
     148                                }
     149
     150                                // Espèces et taxons créés manuellement (non importés).
     151                                $data = array();
     152                                if ($import['contenu'][$_regne]['especes']) {
     153                                        $data['fusionner'] = _T('taxonomie:import_especes_fusionner');
     154                                        // Identifier si le site contient déjà des espèces et décider de l'avertissement
     155                                        // nécessaire et des options.
     156                                        $where = array(
     157                                                'regne=' . sql_quote($_regne),
     158                                                'importe=' . sql_quote('non'),
     159                                                'espece=' . sql_quote('oui')
     160                                        );
     161                                        $nb_especes = sql_countsel('spip_taxons', $where);
     162                                        if ($nb_especes > 0) {
     163                                                $explication = _T('taxonomie:import_especes_explication');
     164                                                $data['ajouter'] = _T('taxonomie:import_especes_ajouter');
     165                                        } else {
     166                                                $explication = _T('taxonomie:import_especes_avertissement');
     167                                        }
     168                                        $saisies[0]['saisies'][] = array(
     169                                                'saisie'  => 'radio',
     170                                                'options' => array(
     171                                                        'nom'         => "${_regne}_import_especes",
     172                                                        'label'       => '<:taxonomie:import_especes_label:>',
     173                                                        'explication' => $explication,
     174                                                        'datas'       => $data,
     175                                                ),
     176                                        );
     177                                }
     178                        }
     179                } else {
     180                        $saisies[0]['saisies'][] = array(
     181                                'saisie'  => 'explication',
     182                                'options' => array(
     183                                        'nom'   => "taxonomie_import_regne",
     184                                        'texte' => '<:taxonomie:import_regne_avertissement:>',
     185                                ),
     186                        );
     187                }
     188
    104189                $flux['data'] = array_merge($flux['data'], $saisies);
    105190        }
    106191
    107192        // Import de la configuration
    108         if (($action == 'import') and isset($flux['args']['config']['noizetier'])) {
     193        if (($action == 'import') and isset($flux['args']['config']['taxonomie'])) {
    109194                // On récupère les demandes d'importation.
    110195                $importation['configuration'] = _request('taxonomie_import_config');
     
    118203                or $importation['compositions_virtuelles']
    119204                or $importation['noisettes']) {
    120                         if (!noizetier_ieconfig_importer($importation, $flux['args']['config']['noizetier'])) {
    121                                 $flux['data'] .= _T('noizetier:ieconfig_probleme_import_config').'<br />';
     205                        if (!taxonomie_ieconfig_importer($importation, $flux['args']['config']['taxonomie'])) {
     206                                $flux['data'] .= _T('taxonomie:ieconfig_probleme_import_config').'<br />';
    122207                        }
    123208                }
     
    164249        // insérés dans la base. Les taxons seront ensuite exportés par règne pour permettre un import plus ciblé.
    165250        include_spip('inc/taxonomie');
    166         $export['regnes'] = array();
    167         $regnes = regne_lister();
     251        $export['contenu']['regnes'] = array();
     252        $regnes = regne_lister_defaut();
    168253        foreach ($regnes as $_regne) {
    169254                if (regne_existe($_regne, $meta_regne)) {
    170                         $export['regnes'][] = $_regne;
    171                 }
    172         }
    173         $export['contenu']['regnes'] = $export['regnes'] ? 'on' : '';
     255                        $export['contenu']['regnes'][] = $_regne;
     256                }
     257        }
    174258
    175259        // Exportation de la table spip_taxons des taxons nécessitant d'être sauvegardés.
     
    184268                // du règne). Ensuite, on sépare aussi les taxons édités (index [taxons][edites]), les taxons créés en tant
    185269                // qu'ascendant d'une espèce (index [taxons][crees]) et les espèces créées manuellement (index [especes]).
    186                 foreach ($export['regnes'] as $_regne) {
     270                foreach ($export['contenu']['regnes'] as $_regne) {
    187271                        // Extraction des taxons du règne au genre édités manuellement par les utilisateurs ou créés lors d'un
    188272                        // ajout d'espèce.
    189273                        // On sauvegarde les champs éditables uniquement des édités et tous les champs pour les autres.
    190274                        $export[$_regne]['taxons'] = taxon_preserver($_regne);
    191                         $export['contenu']['taxons']['edites'][$_regne] = $export[$_regne]['taxons']['edites'] ? 'on' : '';
    192                         $export['contenu']['taxons']['crees'][$_regne] = $export[$_regne]['taxons']['crees'] ? 'on' : '';
     275                        $export['contenu'][$_regne]['taxons']['edites'] = $export[$_regne]['taxons']['edites'] ? 'on' : '';
     276                        $export['contenu'][$_regne]['taxons']['crees'] = $export[$_regne]['taxons']['crees'] ? 'on' : '';
    193277
    194278                        // Extraction des espèces et descendants.
     
    200284                        );
    201285                        $export[$_regne]['especes'] = sql_allfetsel($select, $from, $where);
    202                         $export['contenu']['especes'][$_regne] = $export[$_regne]['especes'] ? 'on' : '';
     286                        $export['contenu'][$_regne]['especes'] = $export[$_regne]['especes'] ? 'on' : '';
    203287                }
    204288        }
     
    227311        $retour = true;
    228312
    229         // On appelle le pipeline pour éventuellement modifier le contenu à importer.
    230         $contenu_import = pipeline('noizetier_config_import', $contenu_import);
    231 
    232         // On récupère la liste des blocs par défaut des pages du site pour filtrer des blocs non autorisés
    233         // provenant éventuellement de l'import. Cette liste sert pour les pages explicites et les compositions virtuelles.
    234         include_spip('inc/noizetier_bloc');
    235         $blocs_defaut = noizetier_bloc_lister_defaut();
    236 
    237313        // La configuration
    238314        if ($importation['configuration']) {
    239315                // On remplace la configuration actuelle par celle du fichier d'import.
    240316                include_spip('inc/config');
    241                 ecrire_config('noizetier', $contenu_import['configuration']);
    242         }
    243 
    244         // Les pages explicites
    245         if ($importation['pages_explicites']) {
    246                 // On fusionne les blocs exclus de la configuration avec ceux des pages explicites de la base.
    247                 // -- On récupère toutes les pages de la base avec leur blocs exclus
    248                 $select = array('page', 'blocs_exclus');
    249                 $where = array('est_virtuelle=' . sql_quote('non'));
    250                 $pages_explicites_base = sql_allfetsel($select,'spip_noizetier_pages', $where);
    251                 // -- on structure les blocs exclus du fichier d'import sous la forme [page] = blocs exclus
    252                 $blocs_exclus_import = array_column($contenu_import['pages_explicites'], 'blocs_exclus', 'page');
    253                 // -- on compare les pages de la base et celles de l'import et on met à jour systématiquement
    254                 //    les pages communes (même identifiant).
    255                 foreach ($pages_explicites_base as $_page_explicite) {
    256                         if (isset($blocs_exclus_import[$_page_explicite['page']])) {
    257                                 // Remplacement des blocs exclus de la page actuelle par ceux du fichier d'import. On filtre
    258                                 // les blocs éventuellement non autorisés sur le site.
    259                                 $modification = array(
    260                                         'blocs_exclus' => array_intersect($blocs_exclus_import[$_page_explicite['page']], $blocs_defaut)
    261                                 );
    262                                 $where = array('page=' . sql_quote($_page_explicite['page']));
    263                                 sql_updateq('spip_noizetier_pages', $modification, $where);
    264                         }
    265                 }
    266         }
    267 
    268         // Les compositions virtuelles
    269         if ($importation['compositions_virtuelles']) {
    270                 if ($importation['compositions_virtuelles'] == 'remplacer') {
    271                         // On vide d'abord la table spip_noizetier_pages de toutes le compositions virtuelles du noiZetier.
    272                         $where = array('est_virtuelle=' . sql_quote('oui'));
    273                         if (!sql_delete('spip_noizetier_pages', $where)) {
    274                                 $retour = false;
    275                         }
    276                 }
    277 
    278                 if ($retour) {
    279                         // On collecte les compositions virtuelles actuellement en base.
    280                         $select = array('page');
    281                         $where = array('est_virtuelle=' . sql_quote('oui'));
    282                         $compositions_base = sql_allfetsel($select, 'spip_noizetier_pages', $where);
    283                         if ($compositions_base) {
    284                                 $compositions_base = array_map('reset', $compositions_base);
    285                         }
    286 
    287                         // Suivant le mode d'importation et l'existence ou pas de la composition en base on ajoute ou
    288                         // on met à jour la composition virtuelle ou on ne fait rien.
    289                         foreach ($contenu_import['compositions_virtuelles'] as $_composition) {
    290                                 // On filtre les blocs exclus avec la liste des blocs par défaut du site.
    291                                 $composition = $_composition;
    292                                 $composition['blocs_exclus'] = array_intersect($composition['blocs_exclus'], $blocs_defaut);
    293 
    294                                 // On détermine l'opération à faire ou pas.
    295                                 if (in_array($composition['page'], $compositions_base)) {
    296                                         if ($importation['compositions_virtuelles'] == 'fusionner') {
    297                                                 $where = 'page=' . sql_quote($composition['page']);
    298                                                 unset($composition['page']);
    299                                                 sql_updateq('spip_noizetier_pages', $composition, $where);
    300                                         }
    301                                 } else {
    302                                         sql_insertq('spip_noizetier_pages', $composition);
    303                                 }
    304                         }
    305                 }
    306         }
    307 
    308         // Les noisettes
    309         if ($importation['noisettes']) {
    310                 if ($importation['noisettes'] == 'remplacer') {
    311                         // On vide d'abord la table spip_noisettes de toutes les noisettes du noiZetier.
    312                         $where = array('plugin=' . sql_quote('noizetier'));
    313                         if (sql_delete('spip_noisettes', $where) === false) {
    314                                 $retour = false;
    315                         }
    316                 }
    317 
    318                 if ($retour) {
    319                         // Liste des pages génériques disponibles dans la base.
    320                         $pages_base = sql_allfetsel('page','spip_noizetier_pages');
    321                         $pages_base = array_map('reset', $pages_base);
    322 
    323                         // Nombre de noisettes par conteneur. On récupère l'ensemble des conteneurs y compris les noisettes
    324                         // conteneur mais seuls les blocs Z du noiZetier sont utiles.
    325                         $select = array('id_conteneur', 'count(*) as nb_noisettes');
    326                         $where = array('plugin=' . sql_quote('noizetier'));
    327                         $group_by = array('id_conteneur');
    328                         $nb_noisettes_base = sql_allfetsel($select, 'spip_noisettes', $where, $group_by);
    329                         if ($nb_noisettes_base) {
    330                                 $nb_noisettes_base = array_column($nb_noisettes_base, 'nb_noisettes', 'id_conteneur');
    331                         }
    332 
    333                         // On insère les noisettes du fichier d'import appartenant à des pages ou des objets disponibles dans la
    334                         // base. Dans le fichier d'export, les noisettes conteneur sont classées avant les autres noisettes et
    335                         // suivant une profondeur croissante de façon à être créées quand les noisettes imbriquées le nécessiteront.
    336                         // Cette opération se fait en deux passes pour gérer le fait que les noisettes conteneur vont
    337                         // changer d'id ce qui change leur identifiant de conteneur :
    338                         // - Passe 1 : si la noisette est à insérer on l'ajoute dans le conteneur sans se préoccuper du changement
    339                         //             d'id de conteneur pour les noisettes conteneur. On stocke toutes les informations nécessaires
    340                         //             à la passe 2 comme le nouvel id des noisettes conteneur.
    341                         include_spip('base/objets');
    342                         include_spip('inc/ncore_conteneur');
    343                         include_spip('inc/ncore_noisette');
    344                         $noisettes_conteneur = $noisettes_imbriquees = array();
    345                         foreach ($contenu_import['noisettes'] as $_id_noisette_ancien => $_noisette) {
    346                                 // On vérifie qu'il faut bien importer la noisette
    347                                 $noisette_a_importer = false;
    348                                 if ($_noisette['type']) {
    349                                         $page_import = $_noisette['composition']
    350                                                 ? $_noisette['type'] . '-' . $_noisette['composition']
    351                                                 : $_noisette['type'];
    352                                         if (in_array($page_import, $pages_base)) {
    353                                                 $noisette_a_importer = true;
    354                                         }
    355                                 } else {
    356                                         $table_objet = table_objet_sql($_noisette['objet']);
    357                                         $id_table_objet = id_table_objet($_noisette['objet']);
    358                                         $where = array($id_table_objet. '=' . intval($_noisette['id_objet']));
    359                                         if (sql_countsel($table_objet, $where)) {
    360                                                 $noisette_a_importer = true;
    361                                         }
    362                                 }
    363 
    364                                 if ($noisette_a_importer) {
    365                                         // La noisette à importer est bien associée à une page ou un objet de la base.
    366                                         // Les noisettes ne sont pas triées dans l'ordre d'insertion pour un conteneur donné,
    367                                         // il faut donc se baser sur le rang dans le fichier d'import. Pour une noisette appartenant à un
    368                                         // conteneur noisette on reprend le rang tel que mais pour une noisette incluse dans un bloc Z il
    369                                         // faut recalculer le rang en tenant compte des noisettes déjà incluses dans la base.
    370                                         $rang = $_noisette['rang_noisette'];
    371                                         $conteneur = unserialize($_noisette['conteneur']);
    372                                         $conteneur_est_noisette = conteneur_est_noisette('noizetier', $conteneur);
    373                                         if (!$conteneur_est_noisette) {
    374                                                 $rang_max = !empty($nb_noisettes_base[$_noisette['id_conteneur']])
    375                                                         ? $nb_noisettes_base[$_noisette['id_conteneur']]
    376                                                         : 0;
    377                                                 $rang += $rang_max;
    378                                         }
    379                                         $id_noisette_nouveau = noisette_ajouter(
    380                                                 'noizetier',
    381                                                 $_noisette['type_noisette'],
    382                                                 $conteneur,
    383                                                 $rang);
    384                                         // La noisette a été ajoutée de façon générique (paramètres par défaut). Pour finaliser l'importation
    385                                         // il faut aussi mettre à jour les données paramétrables : parametres, encapsulation et css.
    386                                         if ($id_noisette_nouveau) {
    387                                                 $champs_modifiables = array('parametres');
    388                                                 if ($_noisette['est_conteneur'] != 'oui') {
    389                                                         $champs_modifiables = array_merge($champs_modifiables, array('parametres', 'encapsulation', 'css'));
    390                                                 }
    391                                                 $modifications = array_intersect_key($_noisette, array_flip($champs_modifiables));
    392                                                 noisette_parametrer('noizetier', $id_noisette_nouveau, $modifications);
    393                                         }
    394 
    395                                         // Pour conclure il faut stocker les informations nécessaires à la passe suivante:
    396                                         // - les noisettes imbriquées dans un conteneur noisette et les référence de ce conteneur
    397                                         // - la nouvelle valeur de l'id_noisette des noisettes conteneur
    398                                         if ($conteneur_est_noisette) {
    399                                                 // Il faut se rappeler de la noisette car il faudra changer son conteneur (2 champs) lors de la
    400                                                 // deuxième passe. On stocke
    401                                                 $noisettes_imbriquees[$id_noisette_nouveau] = array(
    402                                                         'type_noisette' => $conteneur['type_noisette'],
    403                                                         'id_noisette' => $conteneur['id_noisette']
    404                                                 );
    405                                         }
    406                                         if ($_noisette['est_conteneur'] == 'oui') {
    407                                                 // La noisette est un conteneur. On constitue un tableau permettant de calculer son nouvel
    408                                                 // identifiant induit par son nouvel id de noisette. Le tableau est indexé par son ancien id.
    409                                                 $noisettes_conteneur[$_id_noisette_ancien] = $id_noisette_nouveau;
    410                                         }
    411                                 }
    412                         }
    413 
    414                         // - Passe 2 : On reprend les noisettes venant d'être insérées dans une noisette conteneur et
    415                         //             on rétablit le bon conteneur (id et tableau sérialisé), la profondeur et les informations
    416                         //             du bloc Z accueillant les noisettes.
    417                         if ($noisettes_imbriquees) {
    418                                 foreach ($noisettes_imbriquees as $_id_noisette_nouveau => $_conteneur_ancien) {
    419                                         // Détermination du conteneur
    420                                         $nouveau_conteneur = $_conteneur_ancien;
    421                                         $nouveau_conteneur['id_noisette'] = $noisettes_conteneur[$_conteneur_ancien['id_noisette']];
    422 
    423                                         // Détermination de la profondeur et des caractéristiques du bloc Z de plus haut niveau.
    424                                         // Le conteneur est une noisette, qui a été insérée précédemment, on la lit.
    425                                         $select = array('type', 'composition', 'objet', 'id_objet',     'bloc', 'profondeur');
    426                                         $where = array(
    427                                                 'id_noisette=' . intval($nouveau_conteneur['id_noisette']),
    428                                                 'plugin=' . sql_quote('noizetier')
    429                                         );
    430                                         $modifications = sql_fetsel($select, 'spip_noisettes', $where);
    431 
    432                                         // On finalise les modifications
    433                                         $modifications['profondeur'] += 1;
    434                                         $modifications['conteneur'] = serialize($nouveau_conteneur);
    435                                         $modifications['id_conteneur'] = conteneur_identifier('noizetier', $nouveau_conteneur);
    436 
    437                                         // On met à jour le contenu de la noisette en base.
    438                                         $where = array('plugin=' . sql_quote('noizetier'), 'id_noisette=' . intval($_id_noisette_nouveau));
    439                                         sql_updateq('spip_noisettes', $modifications, $where);
    440                                 }
    441                         }
    442                 }
     317                ecrire_config('taxonomie', $contenu_import['configuration']);
    443318        }
    444319
    445320        // On invalide le cache
    446321        include_spip('inc/invalideur');
    447         suivre_invalideur('noizetier-import-config');
     322        suivre_invalideur('taxonomie-import-config');
    448323
    449324        return $retour;
Note: See TracChangeset for help on using the changeset viewer.