Changeset 113120 in spip-zone


Ignore:
Timestamp:
Dec 25, 2018, 9:46:54 PM (3 weeks ago)
Author:
root
Message:

Mise à jour de l'importation ieconfig.
Attention l'importation des noisettes n'est pas encore opérationnelle et de toute façon tous les exports des versions précédentes sont incompatibles maintenant.

Location:
_plugins_/noizetier/trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/noizetier/trunk/formulaires/editer_page.php

    r112598 r113120  
    257257        }
    258258
    259         // Mise ou insertion de la composition virtuelle
     259        // Mise à jour ou insertion de la composition virtuelle
    260260        if ($edition == 'modifier') {
    261261                // -- Update de la composition modifiée
  • _plugins_/noizetier/trunk/lang/noizetier_fr.php

    r112737 r113120  
    105105        'formulaire_icon_explication' => 'Vous pouvez saisir le chemin relatif vers une icône (par exemple : <i>images/objet-liste-contenus.png</i>).',
    106106        'formulaire_identifiant_deja_pris' => 'Cet identifiant est déjà utilisé !',
    107         'formulaire_import_contenu' => 'Choisissez les éléments à importer',
    108         'formulaire_import_contenu_compositions_virtuelles' => 'Les compositions virtuelles',
    109         'formulaire_import_contenu_configuration' => 'La configuration du plugin',
    110         'formulaire_import_contenu_noisettes' => 'Les noisettes',
    111         'formulaire_import_contenu_pages_explicites' => 'Les blocs exclus des pages explicites',
    112         'formulaire_import_fusion' => 'Fusionner avec la configuration actuelle',
    113         'formulaire_import_remplacer' => 'Remplacer la configuration actuelle',
    114         'formulaire_import_resume' => 'Le fichier à importer a été construit avec le noiZetier en version @version@, schéma de données @schema@.',
    115107        'formulaire_liste_compos_config' => 'L’import contient les compositions virtuelles suivantes : @liste@.',
    116108        'formulaire_liste_pages_config' => 'Les pages et compositions explicites ainsi que les objets suivants sont associées à des noisettes : @liste@.',
     
    137129        // I
    138130        'icone_introuvable' => 'Icône introuvable !',
     131        'formulaire_import_contenu' => 'Choisissez les éléments à importer',
     132        'formulaire_import_contenu_compositions_virtuelles' => 'Les compositions virtuelles',
     133        'import_configuration_avertissement' => 'La version @version@ du plugin noiZetier actif sur ce site possède un schéma @schema@ différent de celui du fichier d\'import. <b>Vérifier la compatibilité des configurations avant d\'importer celle du fichier</b>.',
     134        'import_configuration_explication' => 'La version @version@ du plugin noiZetier actif sur ce site possède le même schéma @schema@ que celui du fichier d\'import',
     135        'import_configuration_label' => 'La configuration du plugin',
     136        'import_configuration_labelcase' => 'Remplacer la configuration actuelle par celle du fichier d\'import',
     137        'import_pages_explicites_label' => 'Les blocs exclus des pages explicites',
     138        'import_pages_explicites_labelcase' => 'Importer les blocs exclus dans les pages explicites existantes',
     139        'import_pages_explicites_explication' => 'Il existe des pages et compositions explicites communes entre la base et le fichier d\'import',
     140        'import_pages_explicites_avertissement1' => 'Il n\'existe pas de pages ou compositions explicites communes entre la base et le fichier d\'import. Toute importation est donc inutile.',
     141        'import_pages_explicites_avertissement2' => 'Aucune pages ou compositions explicites disponibles en base. Toute importation est donc inutile.',
     142        'import_noisettes_label' => 'Les noisettes',
     143        'import_noisettes_ajouter' => 'Ajouter noisettes du fichier d\'import dans les pages concernées. Le noisettes actuellement dans la base ne seront pas modifiées.',
     144        'import_noisettes_remplacer' => 'Remplacer par les noisettes du fichier d\'import les noisettes de la base pour les pages concernées.',
     145        'import_noisettes_explication' => 'Il existe des pages communes dans la base et dans le fichier d\'import qui possèdent des noisettes',
     146        'import_noisettes_avertissement1' => 'Il n\'existe pas de pages communes dans la base et dans le fichier d\'import qui possèdent des noisettes. Aucune importation n\'est donc possible.',
     147        'import_noisettes_avertissement2' => 'Aucune noisette n\'est disponible dans le fichier d\'import. Aucune importation n\'est donc possible.',
     148        'import_compositions_virtuelles_label' => 'Les compositions virtuelles',
     149        'import_compositions_virtuelles_explication' => 'Il existe des compositions virtuelles dans la base et dans le fichier d\'import',
     150        'import_compositions_virtuelles_avertissement1' => 'Il n\'existe pas de compositions virtuelles dans la base. Il est juste possible d\importer celles du fichier d\'import.',
     151        'import_compositions_virtuelles_avertissement2' => 'Aucune composition virtuelle n\'est disponible dans le fichier d\'import. Aucune importation n\'est donc possible.',
     152        'import_compositions_virtuelles_ajouter' => 'Ajouter les compositions virtuelles du fichier d\'import. Les compositions de la base aussi disponibles dans le fichier d\import ne seront pas modifiées.',
     153        'import_compositions_virtuelles_fusionner' => 'Ajouter les compositions virtuelles du fichier d\'import et remplacer les compositions de la base aussi disponibles dans le fichier d\'import.',
     154        'import_compositions_virtuelles_remplacer' => 'Remplacer les compositions virtuelles de la base par celles du fichiers d\'import',
     155        'import_resume' => 'Le fichier à importer a été construit avec le noiZetier en version @version@, schéma de données @schema@.',
    139156        'ieconfig_ne_pas_importer' => 'Ne pas importer',
    140157        'ieconfig_noizetier_export_explication' => 'Exporte la configuration du plugin et les données de production concernant les compositions virtuelles et les noisettes.',
  • _plugins_/noizetier/trunk/noizetier_ieconfig.php

    r112827 r113120  
    5151        } elseif (($action == 'form_import') and isset($flux['args']['config']['noizetier'])) {
    5252                // Construire le formulaire d'import :
    53                 // -- On affiche un résumé du contenu du fichier d'import
     53                // On affiche la version du noiZetier et le schéma de base de données avec lesquels le fichier d'import
     54                // à été créé.
    5455                $import = $flux['args']['config']['noizetier'];
    5556                $texte_explication = _T(
    56                         'noizetier:formulaire_import_resume',
     57                        'noizetier:import_resume',
    5758                        array('version' => $import['version'], 'schema' => $import['schema']));
     59
     60                // La configuration : une case suffit car on applique toujours un remplacement et la configuration est
     61                // toujours présente dans un export.
     62                $informer_plugin = chercher_filtre('info_plugin');
     63                $version = $informer_plugin('noizetier', 'version', true);
     64                $schema = $informer_plugin('noizetier', 'schema');
     65                if ($schema == $import['schema']) {
     66                        $explication_config = _T(
     67                                'noizetier:import_configuration_explication',
     68                                array('version' => $version, 'schema' => $schema));
     69                } else {
     70                        $explication_config = _T(
     71                                'noizetier:import_configuration_avertissement',
     72                                array('version' => $version, 'schema' => $schema));
     73                }
     74
     75                // Les pages explicites : seuls les bloc exclus peuvent être restaurés. Une case suffit car on applique
     76                // toujours une fusion des blocs exclus sur les pages de la base ayant le même identifiant.
     77                // On désactive toutefois l'option si aucune page explicite n'est commune entre les deux listes.
     78                $disable_pages_explicites = false;
     79                $select = array('page');
     80                $where = array('est_virtuelle=' . sql_quote('non'));
     81                if ($pages_explicites = sql_allfetsel($select,'spip_noizetier_pages', $where)) {
     82                        $pages_explicites = array_map('reset', $pages_explicites);
     83                        if (count(array_intersect($pages_explicites, array_column($import['pages_explicites'], 'page'))) > 0) {
     84                                $explication_pages_explicites = _T('noizetier:import_pages_explicites_explication');
     85                        } else {
     86                                // Aucune page explicite commune entre la base et le fichier d'import.
     87                                $disable_pages_explicites = true;
     88                                $explication_pages_explicites = _T('noizetier:import_pages_explicites_avertissement1');
     89                        }
     90                } else {
     91                        // Aucune page explicite dans la base, ce n'est pas normal mais on envoie quand un même un avertissement.
     92                        $disable_pages_explicites = true;
     93                        $explication_pages_explicites = _T('noizetier:import_pages_explicites_avertissement2');
     94                }
     95
     96                // Les compositions virtuelles : 3 possibilités en radio, remplacement, ajout (avec vérification de
     97                // l'absence d'une composition identique) et la fusion avec ajout. Si aucune composition virtuelle dans la
     98                // base seul l'ajout est possible et si aucune composition virtuelle n'est incluse dans l'import on ne propose
     99                // aucune action.
     100                $data_compositions = array();
     101                if ($import['contenu']['compositions_virtuelles']) {
     102                        $data_compositions['ajouter'] = _T('noizetier:import_compositions_virtuelles_ajouter');
     103                        $where = array('est_virtuelle=' . sql_quote('oui'));
     104                        if (!sql_countsel('spip_noizetier_pages', $where)) {
     105                                $explication_compositions = _T('noizetier:import_compositions_virtuelles_avertissement1');
     106                        } else {
     107                                $data_compositions['remplacer'] = _T('noizetier:import_compositions_virtuelles_remplacer');
     108                                $data_compositions['fusionner'] = _T('noizetier:import_compositions_virtuelles_fusionner');
     109                                $explication_compositions = _T('noizetier:import_compositions_virtuelles_explication');
     110                        }
     111                } else {
     112                        $explication_compositions = _T('noizetier:import_compositions_virtuelles_avertissement2');
     113                }
     114
     115                // -- Les noisettes : 2 possibilités en radio, remplacement ou ajout.
     116                $data_noisettes = array();
    58117                if ($import['contenu']['noisettes']) {
    59                         include_spip('inc/noizetier_conteneur');
    60                         $pages = array();
     118                        $pages_base = sql_allfetsel('page','spip_noizetier_pages');
     119                        $pages_base = array_map('reset', $pages_base);
     120
     121                        include_spip('base/objets');
     122                        $importation_noisettes_possible = false;
    61123                        foreach ($import['noisettes'] as $_noisette) {
    62                                 $conteneur = noizetier_conteneur_decomposer($_noisette['id_conteneur']);
    63                                 $pages[] = !empty($conteneur['page'])
    64                                         ? $conteneur['page']
    65                                         : $conteneur['objet'] . $conteneur['id_objet'];
    66                         }
    67                         $pages = array_unique($pages);
    68                         $texte_explication .= '<br />'
    69                                 . _T('noizetier:formulaire_liste_pages_config', array('liste' => implode(', ', $pages)));
    70                 }
    71                 if ($import['contenu']['compositions_virtuelles']) {
    72                         $compositions = array();
    73                         foreach ($import['compositions_virtuelles'] as $_composition) {
    74                                 $compositions[] = $_composition['page'];
    75                         }
    76                         $texte_explication .= '<br />'
    77                                 . _T('noizetier:formulaire_liste_compos_config', array('liste' => implode(', ', $compositions)));
    78                 }
    79 
    80                 // -- Construire la saisie permettant de proposer chaque contenu de l'export (configuration, noisettes,
    81                 //    pages explicites et compositions virtuelles).
    82                 $contenu_data = $contenu_defaut = $contenu_disable = array();
    83                 foreach ($import['contenu'] as $_contenu => $_valeur) {
    84                         $contenu_data[$_contenu] = _T("noizetier:formulaire_import_contenu_{$_contenu}");
    85                         if (!$_valeur) {
    86                                 $contenu_disable[] = $_contenu;
     124                                if ($_noisette['type']) {
     125                                        $page_import = $_noisette['composition']
     126                                                ? $_noisette['type'] . '-' . $_noisette['composition']
     127                                                : $_noisette['type'];
     128                                        if (in_array($page_import, $pages_base)) {
     129                                                $importation_noisettes_possible = true;
     130                                                break;
     131                                        }
     132                                } else {
     133                                        $table_objet = table_objet_sql($_noisette['objet']);
     134                                        $id_table_objet = id_table_objet($_noisette['objet']);
     135                                        $where = array($id_table_objet. '=' . intval($_noisette['id_objet']));
     136                                        if (sql_countsel($table_objet, $where)) {
     137                                                $importation_noisettes_possible = true;
     138                                                break;
     139                                        }
     140                                }
     141                        }
     142
     143                        if ($importation_noisettes_possible) {
     144                                $data_noisettes = array(
     145                                        'remplacer' => '<:noizetier:import_noisettes_remplacer:>',
     146                                        'ajouter'   => '<:noizetier:import_noisettes_ajouter:>'
     147                                );
     148                                $explication_noisettes = _T('noizetier:import_noisettes_explication');
    87149                        } else {
    88                                 $contenu_defaut[] = $_contenu;
    89                         }
    90                 }
     150                                // Aucune page commune entre la base et le fichier d'import.
     151                                $explication_noisettes = _T('noizetier:import_noisettes_avertissement1');
     152                        }
     153                } else {
     154                        $explication_noisettes = _T('noizetier:import_noisettes_avertissement2');
     155                }
     156
    91157                $saisies = array(
    92158                        array(
    93                                 'saisie' => 'fieldset',
     159                                'saisie'  => 'fieldset',
    94160                                'options' => array(
    95                                         'nom' => 'noizetier_export',
     161                                        'nom'   => 'noizetier_export',
    96162                                        'label' => '<:noizetier:noizetier:>',
    97163                                        'icone' => 'noizetier-24.png',
     
    99165                                'saisies' => array(
    100166                                        array(
    101                                                 'saisie' => 'explication',
    102                                                 'options' => array(
    103                                                         'nom' => 'noizetier_export_explication',
     167                                                'saisie'  => 'explication',
     168                                                'options' => array(
     169                                                        'nom'   => 'noizetier_export_explication',
    104170                                                        'texte' => $texte_explication,
    105171                                                ),
    106172                                        ),
    107173                                        array(
    108                                                 'saisie' => 'checkbox',
    109                                                 'options' => array(
    110                                                         'nom' => 'noizetier_import_contenu',
    111                                                         'label' => '<:noizetier:formulaire_import_contenu:>',
    112 //                                                      'defaut' => $contenu_defaut,
    113                                                         'datas' => $contenu_data,
    114                                                         'disable' => $contenu_disable
    115                                                 ),
    116                                         ),
    117                                         array(
    118                                                 'saisie' => 'radio',
    119                                                 'options' => array(
    120                                                         'nom' => 'noizetier_type_import',
    121                                                         'label' => '<:noizetier:formulaire_type_import:>',
    122                                                         'explication' => '<:noizetier:formulaire_type_import_explication:>',
    123                                                         'defaut' => 'remplacer',
    124                                                         'datas' => array(
    125                                                                 'fusion' => '<:noizetier:formulaire_import_fusion:>',
    126                                                                 'remplacer' => '<:noizetier:formulaire_import_remplacer:>',
    127                                                         ),
     174                                                'saisie'  => 'case',
     175                                                'options' => array(
     176                                                        'nom'         => 'noizetier_import_config',
     177                                                        'label'       => '<:noizetier:import_configuration_label:>',
     178                                                        'label_case'  => '<:noizetier:import_configuration_labelcase:>',
     179                                                        'explication' => $explication_config
     180                                                ),
     181                                        ),
     182                                        array(
     183                                                'saisie'  => 'case',
     184                                                'options' => array(
     185                                                        'nom'         => 'noizetier_import_pages',
     186                                                        'label'       => '<:noizetier:import_pages_explicites_label:>',
     187                                                        'label_case'  => '<:noizetier:import_pages_explicites_labelcase:>',
     188                                                        'explication' => $explication_pages_explicites,
     189                                                        'disable'     => $disable_pages_explicites
     190                                                ),
     191                                        ),
     192                                        array(
     193                                                'saisie'  => 'radio',
     194                                                'options' => array(
     195                                                        'nom'         => 'noizetier_import_compositions',
     196                                                        'label'       => '<:noizetier:import_compositions_virtuelles_label:>',
     197                                                        'datas'       => $data_compositions,
     198                                                        'explication' => $explication_compositions
     199                                                ),
     200                                        ),
     201                                        array(
     202                                                'saisie'  => 'radio',
     203                                                'options' => array(
     204                                                        'nom'         => 'noizetier_import_noisettes',
     205                                                        'label'       => '<:noizetier:import_noisettes_label:>',
     206                                                        'datas'       => $data_noisettes,
     207                                                        'explication' => $explication_noisettes
    128208                                                ),
    129209                                        ),
     
    135215
    136216        // Import de la configuration
    137         if (($action == 'import')
    138         and isset($flux['args']['config']['noizetier'])
    139         and (_request('noizetier_type_import') != '')) {
    140                 if (!noizetier_ieconfig_importer(_request('noizetier_type_import'), _request('noizetier_import_contenu'), $flux['args']['config']['noizetier'])) {
    141                         $flux['data'] .= _T('noizetier:ieconfig_probleme_import_config').'<br />';
     217        if (($action == 'import') and isset($flux['args']['config']['noizetier'])) {
     218                // On récupère les demandes d'importation.
     219                $importation['configuration'] = _request('noizetier_import_config');
     220                $importation['pages_explicites'] = _request('noizetier_import_pages');
     221                $importation['compositions_virtuelles'] = _request('noizetier_import_compositions');
     222                $importation['noisettes'] = _request('noizetier_import_noisettes');
     223
     224                // Si au moins l'une est requise on appelle la fonction d'import.
     225                if ($importation['configuration']
     226                or $importation['pages_explicites']
     227                or $importation['compositions_virtuelles']
     228                or $importation['noisettes']) {
     229                        if (!noizetier_ieconfig_importer($importation, $flux['args']['config']['noizetier'])) {
     230                                $flux['data'] .= _T('noizetier:ieconfig_probleme_import_config').'<br />';
     231                        }
    142232                }
    143233        }
     
    152242
    153243/**
    154  * Retourne le tableau des noisettes et des compositions du noizetier pour les exports.
     244 * Retourne le tableau d'export du noiZetier contenant toujours sa configuration, les blocs exclus des pages
     245 * explicites, la description complète des compositions virtuelles et la description complète des noisettes.
    155246 *
    156  * @return
     247 * @return array
     248 *         Tableau d'export pour le pipeline ieconfig_exporter.
    157249 **/
    158250function noizetier_ieconfig_exporter() {
     
    162254        // Insérer une en-tête qui permet de connaitre la version du noiZetier utilisé lors de l'export
    163255        $informer_plugin = chercher_filtre('info_plugin');
    164         $export['version'] = $informer_plugin('noizetier', 'version');
     256        $export['version'] = $informer_plugin('noizetier', 'version', true);
    165257        $export['schema'] = $informer_plugin('noizetier', 'schema');
    166258        $export['contenu'] = array();
     
    172264        $export['configuration'] = lire_config('noizetier', array());
    173265        $export['contenu']['configuration'] = $export['configuration'] ? 'on' : '';
    174 
    175         // Exportation de la tables spip_noisettes qui contient les noisettes associées aux pages explicites,
    176         // aux compositions virtuelles et à certains objets précis.
    177         // -- on supprime l'id_noisette de chaque noisette car il sera recréé lors de l'import.
    178         include_spip('ncore_fonctions');
    179         $export['noisettes'] = noisette_repertorier('noizetier', array(), 'id_noisette');
    180         foreach($export['noisettes'] as $_id => $_noisette) {
    181                 unset($export['noisettes'][$_id]['id_noisette']);
    182         }
    183         $export['contenu']['noisettes'] = $export['noisettes'] ? 'on' : '';
    184266
    185267        // Exportation de la tables spip_noizetier_pages qui contient les pages explicites et compositions virtuelles.
     
    202284        $export['contenu']['compositions_virtuelles'] = $export['compositions_virtuelles'] ? 'on' : '';
    203285
     286        // Exportation de la tables spip_noisettes qui contient les noisettes associées aux pages explicites,
     287        // aux compositions virtuelles et à certains objets précis.
     288        // -- on supprime l'id_noisette de chaque noisette car il sera recréé lors de l'import.
     289        include_spip('ncore_fonctions');
     290        $export['noisettes'] = noisette_repertorier('noizetier', array(), 'id_noisette');
     291        foreach($export['noisettes'] as $_id => $_noisette) {
     292                unset($export['noisettes'][$_id]['id_noisette']);
     293        }
     294        $export['contenu']['noisettes'] = $export['noisettes'] ? 'on' : '';
     295
    204296        // Appel d'un pipeline propre à l'export du noiZetier pour autoriser la modification par des plugins
    205297        // de la structure d'export
     
    210302
    211303/**
    212  * Importe une configuration de noisettes et de compositions.
     304 * Importe tout ou partie d'un fichier d'export ieconfig contenant les données du noiZetier.
    213305 *
    214  * @param string  $type_import
    215  * @param string  $import_contenu
    216  * @param array $config
     306 * @param array $importation
     307 *        Tableau associatif des demandes d'importation issues du formulaire ieconfig. Les index et les valeurs
     308 *        possibles sont :
     309 *        - `configuration` : vaut `on` pour importer ou null sinon
     310 *        - `pages_explicites` : vaut `on` pour importer ou null sinon
     311 *        - `compositions_virtuelles` : vaut `remplacer`, `ajouter` ou `fusionner` pour importer ou null sinon.
     312 *        - `noisettes` : vaut `remplacer` ou `ajouter` pour importer ou null sinon.
     313 * @param array $contenu_import
     314 *        Tableau des données du noiZetier issues du fichier d'import.
    217315 *
    218316 * @return bool
    219317 */
    220 function noizetier_ieconfig_importer($type_import, $import_contenu, $config) {
    221         if ($type_import != 'remplacer') {
    222                 $type_import = 'fusion';
    223         }
    224         if ($import_contenu != 'oui') {
    225                 $import_contenu = 'non';
    226         }
    227 
    228         $config = pipeline('noizetier_config_import', $config);
    229 
    230         // On s'occupe deja des noisettes
    231         $noisettes = $config['noisettes'];
    232         include_spip('base/abstract_sql');
    233         if (is_array($noisettes) and count($noisettes) > 0) {
    234                 $noisettes_insert = array();
    235                 $rang = 1;
    236                 $page = '';
    237 
    238                 if ($type_import == 'remplacer') {
    239                         sql_delete('spip_noisettes', '1');
    240                 }
    241 
    242                 foreach ($noisettes as $noisette) {
    243                         $type = $noisette['type'];
    244                         $composition = $noisette['composition'];
    245                         if ($type.'-'.$composition != $page) {
    246                                 $page = $type.'-'.$composition;
    247                                 $rang = 1;
    248                                 if ($type_import == 'fusion') {
    249                                         $rang = sql_getfetsel('rang_noisette', 'spip_noisettes', 'type='.sql_quote($type).' AND composition='.sql_quote($composition), '', 'rang DESC') + 1;
     318function noizetier_ieconfig_importer($importation, $contenu_import) {
     319
     320        // Initialisation de la sortie
     321        $retour = true;
     322
     323        // On appelle le pipeline pour éventuellement modifier le contenu à importer.
     324        $contenu_import = pipeline('noizetier_config_import', $contenu_import);
     325
     326        // La configuration
     327        if ($importation['configuration']) {
     328                // On remplace la configuration actuelle par celle du fichier d'import.
     329                include_spip('inc/config');
     330                ecrire_config('noizetier', $contenu_import['configuration']);
     331        }
     332
     333        // Les pages explicites
     334        if ($importation['pages_explicites']) {
     335                // On fusionne les blocs exclus de la configuration avec ceux des pages explicites de la base.
     336                // -- On récupère toutes les pages de la base avec leur blocs exclus
     337                $select = array('page', 'blocs_exclus');
     338                $where = array('est_virtuelle=' . sql_quote('non'));
     339                $pages_explicites_base = sql_allfetsel($select,'spip_noizetier_pages', $where);
     340                // -- on structure les blocs exclus du fichier d'import sous la forme [page] = blocs exclus
     341                $blocs_exclus_import = array_column($contenu_import['pages_explicites'], 'blocs_exclus', 'page');
     342                // -- on compare les pages de la base et celles de l'import et on met à jour systématiquement
     343                //    les pages communes (même identifiant).
     344                foreach ($pages_explicites_base as $_page_explicite) {
     345                        if (isset($blocs_exclus_import[$_page_explicite['page']])) {
     346                                // Remplacement des blocs exclus de la page actuelle par ceux du fichier d'import.
     347                                $modification = array('blocs_exclus' => $blocs_exclus_import[$_page_explicite['page']]);
     348                                $where = array('page=' . sql_quote($_page_explicite['page']));
     349                                sql_updateq('spip_noizetier_pages', $modification, $where);
     350                        }
     351                }
     352        }
     353
     354        // Les compositions virtuelles
     355        if ($importation['compositions_virtuelles']) {
     356                if ($importation['compositions_virtuelles'] == 'remplacer') {
     357                        // On vide d'abord la table spip_noizetier_pages de toutes le compositions virtuelles du noiZetier.
     358                        $where = array('est_virtuelle=' . sql_quote('oui'));
     359                        if (!sql_delete('spip_noizetier_pages', $where)) {
     360                                $retour = false;
     361                        }
     362                }
     363
     364                if ($retour) {
     365                        // On collecte les compositions virtuelles actuellement en base.
     366                        $select = array('page');
     367                        $where = array('est_virtuelle=' . sql_quote('oui'));
     368                        $compositions_base = sql_allfetsel($select, 'spip_noizetier_pages', $where);
     369                        if ($compositions_base) {
     370                                $compositions_base = array_map('reset', $compositions_base);
     371                        }
     372
     373                        // Suivant le mode d'importation et l'existence ou pas de la composition en base on ajoute ou
     374                        // on met à jour la composition virtuelle ou on ne fait rien.
     375                        foreach ($contenu_import['compositions_virtuelles'] as $_composition) {
     376                                if (in_array($_composition['page'], $compositions_base)) {
     377                                        if ($importation['compositions_virtuelles'] == 'fusionner') {
     378                                                $where = 'page=' . sql_quote($_composition['page']);
     379                                                $modifications = $_composition;
     380                                                unset($modifications['page']);
     381                                                sql_updateq('spip_noizetier_pages', $modifications, $where);
     382                                        }
     383                                } else {
     384                                        sql_insertq('spip_noizetier_pages', $_composition);
    250385                                }
    251                         } else {
    252                                 $rang = $rang + 1;
    253                         }
    254                         $noisette['rang_noisette'] = $rang;
    255                         $noisette['parametres'] = serialize($noisette['parametres']);
    256                         $noisettes_insert[] = $noisette;
    257                 }
    258 
    259                 $ok = sql_insertq_multi('spip_noisettes', $noisettes_insert);
    260         }
    261 
    262         // On s'occupe des compositions du noizetier
    263         // TODO : à modifier car les compositions sont dans la table des pages
    264         if ($import_contenu == 'oui') {
    265                 include_spip('inc/meta');
    266                 $compos_importees = $config['noizetier_compositions'];
    267                 if (is_array($compos_importees) and count($compos_importees) > 0) {
    268                         if ($type_import == 'remplacer') {
    269                                 effacer_meta('noizetier_compositions');
    270                         } else {
    271                                 $noizetier_compositions = unserialize($GLOBALS['meta']['noizetier_compositions']);
    272                         }
    273 
    274                         if (!is_array($noizetier_compositions)) {
    275                                 $noizetier_compositions = array();
    276                         }
    277 
    278                         foreach ($compos_importees as $type => $compos_type) {
    279                                 foreach ($compos_type as $composition => $info_compo) {
    280                                         $noizetier_compositions[$type][$composition] = $info_compo;
     386                        }
     387                }
     388        }
     389
     390        // Les noisettes
     391        $importation['noisettes'] = array();
     392        if ($importation['noisettes']) {
     393                if ($importation['noisettes'] == 'remplacer') {
     394                        // On vide d'abord la table spip_noisettes de toutes les noisettes du noiZetier.
     395                        $where = array('plugin=' . sql_quote('noizetier'));
     396                        if (!sql_delete('spip_noisettes', $where)) {
     397                                $retour = false;
     398                        }
     399                }
     400
     401                if ($retour) {
     402                        // Liste des pages génériques disponibles dans la base.
     403                        $pages_base = sql_allfetsel('page','spip_noizetier_pages');
     404                        $pages_base = array_map('reset', $pages_base);
     405
     406                        $champs_modifiables = array_flip(array('parametres', 'encapsulation', 'css'));
     407                        foreach ($contenu_import['noisettes'] as $_noisette) {
     408                                $page_noisette = $_noisette['type']
     409                                        ? ($_noisette['composition'] ? $_noisette['type'] . '-' . $_noisette['composition'] : $_noisette['type'])
     410                                        : $_noisette['objet'] . $_noisette['id_objet'];
     411                                if (!$_noisette['objet'] and in_array($page_noisette, $pages_base)) {
     412                                        // La noisette à importer est bien associée à une page présente dans la base.
     413                                        // On la rajoute en fin du bloc concerné.
     414                                        $id_noisette = noisette_ajouter(
     415                                                'noizetier',
     416                                                $_noisette['type_noisette'],
     417                                                unserialize($_noisette['conteneur']),
     418                                                0);
     419                                        // La noisette a été ajoutée de façon générique. Pour terminer l'importation il faut aussi
     420                                        // mettre à jour les données paramétrables : parametres, encapsulation et css.
     421                                        if ($id_noisette) {
     422                                                $modifications = array_intersect_key($_noisette, $champs_modifiables);
     423                                                noisette_parametrer('noizetier', $id_noisette, $modifications);
     424                                        }
    281425                                }
    282426                        }
    283 
    284                         ecrire_meta('noizetier_compositions', serialize($noizetier_compositions));
    285                         ecrire_metas();
    286427                }
    287428        }
     
    291432        suivre_invalideur('noizetier-import-config');
    292433
    293         return $ok;
     434        return $retour;
    294435}
Note: See TracChangeset for help on using the changeset viewer.