source: spip-zone/_plugins_/noizetier/trunk/noizetier_ieconfig.php @ 112698

Last change on this file since 112698 was 112698, checked in by eric@…, 2 years ago

Adaptation du noizetier à la dernière version de N-Core (encapsulation).
Tout n'est pas fonctionnel, il manque encore :

  • un problème de détection de l'input radio balise_noisette dans la config du noizetier (bug Saisies ???)
  • la prise en compte du mode d'encapsulation auto pour cacher la config balise_noisette et la suppression des saisies balise et css dans l'edition d'une noisette.

A tester.

File size: 10.0 KB
Line 
1<?php
2
3if (!defined('_ECRIRE_INC_VERSION')) {
4        return;
5}
6
7/**
8 * Pipeline ieconfig pour l'import/export de configuration.
9 *
10 * @param array $flux
11 *
12 * @return array
13 */
14function noizetier_ieconfig($flux) {
15
16        // On détermine l'action demandée qui peut être : afficher le formulaire d'export ou d'import, construire le
17        // tableau d'export ou exécuter l'importation.
18        $action = $flux['args']['action'];
19
20        if ($action == 'form_export') {
21                // Construire le formulaire d'export :
22                // -- on demande le minimum à savoir si l'utilisateur veut inclure dans son export l'ensemble des données
23                //    du noiZetier.
24                $saisies = array(
25                        array(
26                                'saisie' => 'fieldset',
27                                'options' => array(
28                                        'nom' => 'noizetier_export',
29                                        'label' => '<:noizetier:noizetier:>',
30                                        'icone' => 'noizetier-24.png',
31                                ),
32                                'saisies' => array(
33                                        array(
34                                                'saisie' => 'oui_non',
35                                                'options' => array(
36                                                        'nom' => 'noizetier_export_option',
37                                                        'label' => '<:noizetier:ieconfig_noizetier_export_option:>',
38                                                        'explication' => '<:noizetier:ieconfig_noizetier_export_explication:>',
39                                                        'defaut' => '',
40                                                ),
41                                        ),
42                                ),
43                        ),
44                );
45                $flux['data'] = array_merge($flux['data'], $saisies);
46
47        } elseif (($action == 'export') and (_request('noizetier_export_option') == 'on')) {
48                // Générer le tableau d'export
49                $flux['data']['noizetier'] = noizetier_ieconfig_exporter();
50
51        } elseif (($action == 'form_import') and isset($flux['args']['config']['noizetier'])) {
52                // Construire le formulaire d'import :
53                // -- On affiche un résumé du contenu du fichier d'import
54                $import = $flux['args']['config']['noizetier'];
55                $texte_explication = _T(
56                        'noizetier:formulaire_import_resume',
57                        array('version' => $import['version'], 'schema' => $import['schema']));
58                if ($import['contenu']['noisettes']) {
59                        include_spip('inc/noizetier_conteneur');
60                        $pages = array();
61                        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;
87                        } else {
88                                $contenu_defaut[] = $_contenu;
89                        }
90                }
91                $saisies = array(
92                        array(
93                                'saisie' => 'fieldset',
94                                'options' => array(
95                                        'nom' => 'noizetier_export',
96                                        'label' => '<:noizetier:noizetier:>',
97                                        'icone' => 'noizetier-24.png',
98                                ),
99                                'saisies' => array(
100                                        array(
101                                                'saisie' => 'explication',
102                                                'options' => array(
103                                                        'nom' => 'noizetier_export_explication',
104                                                        'texte' => $texte_explication,
105                                                ),
106                                        ),
107                                        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                                                        ),
128                                                ),
129                                        ),
130                                ),
131                        ),
132                );
133                $flux['data'] = array_merge($flux['data'], $saisies);
134        }
135
136        // 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 />';
142                }
143        }
144
145        return $flux;
146}
147
148
149// --------------------------------------------------------------------
150// ------------------------- API IMPORT/EXPORT ------------------------
151// --------------------------------------------------------------------
152
153/**
154 * Retourne le tableau des noisettes et des compositions du noizetier pour les exports.
155 *
156 * @return
157 **/
158function noizetier_ieconfig_exporter() {
159
160        $export = array();
161
162        // Insérer une en-tête qui permet de connaitre la version du noiZetier utilisé lors de l'export
163        $informer_plugin = chercher_filtre('info_plugin');
164        $export['version'] = $informer_plugin('noizetier', 'version');
165        $export['schema'] = $informer_plugin('noizetier', 'schema');
166        $export['contenu'] = array();
167
168        // Exportation de la configuration du plugin rangée dans la meta noizetier.
169        // Etant donné que l'on utilise ce pipeline pour les données de production du noiZetier, on exporte aussi
170        // sa configuration via ce pipeline et non via le pipeline ieconfig_metas.
171        include_spip('inc/config');
172        $export['configuration'] = lire_config('noizetier', array());
173        $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('inc/ncore_noisette');
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' : '';
184
185        // Exportation de la tables spip_noizetier_pages qui contient les pages explicites et compositions virtuelles.
186        $from ='spip_noizetier_pages';
187
188        // -- pour les pages explicites il faut sauvegarder les blocs exclus qui peuvent être modifiés après chargement,
189        //    les autres champs n'ont pas d'intérêt à être sauvegardés car ils proviennent du fichier XML/YAML.
190        $select = array('page', 'blocs_exclus');
191        $where = array('est_virtuelle=' . sql_quote('non'));
192        $export['pages_explicites'] = sql_allfetsel($select, $from, $where);
193        $export['contenu']['pages_explicites'] = $export['pages_explicites'] ? 'on' : '';
194
195        // -- pour les compositions virtuelles il faut tout sauvegarder (sauf le timestamp 'maj') car elles sont créées
196        //    de zéro.
197        $trouver_table = charger_fonction('trouver_table', 'base');
198        $table = $trouver_table($from);
199        $select = array_diff(array_keys($table['field']), array('maj'));
200        $where = array('est_virtuelle=' . sql_quote('oui'));
201        $export['compositions_virtuelles'] = sql_allfetsel($select, $from, $where);
202        $export['contenu']['compositions_virtuelles'] = $export['compositions_virtuelles'] ? 'on' : '';
203
204        // Appel d'un pipeline propre à l'export du noiZetier pour autoriser la modification par des plugins
205        // de la structure d'export
206        $export = pipeline('noizetier_config_export', $export);
207
208        return $export;
209}
210
211/**
212 * Importe une configuration de noisettes et de compositions.
213 *
214 * @param string  $type_import
215 * @param string  $import_contenu
216 * @param array $config
217 *
218 * @return bool
219 */
220function 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;
250                                }
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;
281                                }
282                        }
283
284                        ecrire_meta('noizetier_compositions', serialize($noizetier_compositions));
285                        ecrire_metas();
286                }
287        }
288
289        // On invalide le cache
290        include_spip('inc/invalideur');
291        suivre_invalideur('noizetier-import-config');
292
293        return $ok;
294}
Note: See TracBrowser for help on using the repository browser.