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

Last change on this file since 113568 was 113522, checked in by eric@…, 5 months ago

Renommage des API page, objet, bloc et conteneur du noiZetier.

File size: 23.7 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 la version du noiZetier et le schéma de base de données avec lesquels le fichier d'import
54                // à été créé.
55                $import = $flux['args']['config']['noizetier'];
56                $texte_explication = _T(
57                        'noizetier:import_resume',
58                        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();
117                if ($import['contenu']['noisettes']) {
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;
123                        foreach ($import['noisettes'] as $_noisette) {
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');
149                        } else {
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
157                $saisies = array(
158                        array(
159                                'saisie'  => 'fieldset',
160                                'options' => array(
161                                        'nom'   => 'noizetier_export',
162                                        'label' => '<:noizetier:noizetier:>',
163                                        'icone' => 'noizetier-24.png',
164                                ),
165                                'saisies' => array(
166                                        array(
167                                                'saisie'  => 'explication',
168                                                'options' => array(
169                                                        'nom'   => 'noizetier_export_explication',
170                                                        'texte' => $texte_explication,
171                                                ),
172                                        ),
173                                        array(
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
208                                                ),
209                                        ),
210                                ),
211                        ),
212                );
213                $flux['data'] = array_merge($flux['data'], $saisies);
214        }
215
216        // Import de la configuration
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                        }
232                }
233        }
234
235        return $flux;
236}
237
238
239// --------------------------------------------------------------------
240// ------------------------- API IMPORT/EXPORT ------------------------
241// --------------------------------------------------------------------
242
243/**
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.
246 *
247 * @return array
248 *         Tableau d'export pour le pipeline ieconfig_exporter.
249 **/
250function noizetier_ieconfig_exporter() {
251
252        $export = array();
253
254        // Insérer une en-tête qui permet de connaitre la version du noiZetier utilisé lors de l'export
255        $informer_plugin = chercher_filtre('info_plugin');
256        $export['version'] = $informer_plugin('noizetier', 'version', true);
257        $export['schema'] = $informer_plugin('noizetier', 'schema');
258        $export['contenu'] = array();
259
260        // Exportation de la configuration du plugin rangée dans la meta noizetier.
261        // Etant donné que l'on utilise ce pipeline pour les données de production du noiZetier, on exporte aussi
262        // sa configuration via ce pipeline et non via le pipeline ieconfig_metas.
263        include_spip('inc/config');
264        $export['configuration'] = lire_config('noizetier', array());
265        $export['contenu']['configuration'] = $export['configuration'] ? 'on' : '';
266
267        // Exportation de la tables spip_noizetier_pages qui contient les pages explicites et compositions virtuelles.
268        $from ='spip_noizetier_pages';
269
270        // -- pour les pages explicites il faut sauvegarder les blocs exclus qui peuvent être modifiés après chargement,
271        //    les autres champs n'ont pas d'intérêt à être sauvegardés car ils proviennent du fichier XML/YAML.
272        $select = array('page', 'blocs_exclus');
273        $where = array('est_virtuelle=' . sql_quote('non'));
274        $export['pages_explicites'] = sql_allfetsel($select, $from, $where);
275        $export['contenu']['pages_explicites'] = $export['pages_explicites'] ? 'on' : '';
276
277        // -- pour les compositions virtuelles il faut tout sauvegarder (sauf le timestamp 'maj') car elles sont créées
278        //    de zéro.
279        $trouver_table = charger_fonction('trouver_table', 'base');
280        $table = $trouver_table($from);
281        $select = array_diff(array_keys($table['field']), array('maj'));
282        $where = array('est_virtuelle=' . sql_quote('oui'));
283        $export['compositions_virtuelles'] = sql_allfetsel($select, $from, $where);
284        $export['contenu']['compositions_virtuelles'] = $export['compositions_virtuelles'] ? 'on' : '';
285
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 fait en sorte que les noisettes conteneur soient les premiers index suivies des noisettes non conteneur.
289        //    Pour chaque groupe, on sous-classe par profondeur de 0 à n. On utilise donc l'API SQL et pas celle de N-Core.
290        // -- on supprime l'id_noisette de chaque noisette car il sera recréé lors de l'import.
291        $where = array('plugin=' . sql_quote('noizetier'));
292        $order_by = array('est_conteneur DESC', 'profondeur ASC');
293        $noisettes = sql_allfetsel('*', 'spip_noisettes', $where, array(), $order_by);
294        // -- le array_merge a changé les index numériques de 0 à n, il faut remettre les id de noisette.
295        $export['noisettes'] = array_column($noisettes, null, 'id_noisette');
296        foreach($export['noisettes'] as $_id => $_noisette) {
297                unset($export['noisettes'][$_id]['id_noisette']);
298        }
299        $export['contenu']['noisettes'] = $export['noisettes'] ? 'on' : '';
300
301        // Appel d'un pipeline propre à l'export du noiZetier pour autoriser la modification par des plugins
302        // de la structure d'export
303        $export = pipeline('noizetier_config_export', $export);
304
305        return $export;
306}
307
308/**
309 * Importe tout ou partie d'un fichier d'export ieconfig contenant les données du noiZetier.
310 *
311 * @param array $importation
312 *        Tableau associatif des demandes d'importation issues du formulaire ieconfig. Les index et les valeurs
313 *        possibles sont :
314 *        - `configuration` : vaut `on` pour importer ou null sinon
315 *        - `pages_explicites` : vaut `on` pour importer ou null sinon
316 *        - `compositions_virtuelles` : vaut `remplacer`, `ajouter` ou `fusionner` pour importer ou null sinon.
317 *        - `noisettes` : vaut `remplacer` ou `ajouter` pour importer ou null sinon.
318 * @param array $contenu_import
319 *        Tableau des données du noiZetier issues du fichier d'import.
320 *
321 * @return bool
322 */
323function noizetier_ieconfig_importer($importation, $contenu_import) {
324
325        // Initialisation de la sortie
326        $retour = true;
327
328        // On appelle le pipeline pour éventuellement modifier le contenu à importer.
329        $contenu_import = pipeline('noizetier_config_import', $contenu_import);
330
331        // On récupère la liste des blocs par défaut des pages du site pour filtrer des blocs non autorisés
332        // provenant éventuellement de l'import. Cette liste sert pour les pages explicites et les compositions virtuelles.
333        include_spip('inc/noizetier_bloc');
334        $blocs_defaut = bloc_z_lister_defaut();
335
336        // La configuration
337        if ($importation['configuration']) {
338                // On remplace la configuration actuelle par celle du fichier d'import.
339                include_spip('inc/config');
340                ecrire_config('noizetier', $contenu_import['configuration']);
341        }
342
343        // Les pages explicites
344        if ($importation['pages_explicites']) {
345                // On fusionne les blocs exclus de la configuration avec ceux des pages explicites de la base.
346                // -- On récupère toutes les pages de la base avec leur blocs exclus
347                $select = array('page', 'blocs_exclus');
348                $where = array('est_virtuelle=' . sql_quote('non'));
349                $pages_explicites_base = sql_allfetsel($select,'spip_noizetier_pages', $where);
350                // -- on structure les blocs exclus du fichier d'import sous la forme [page] = blocs exclus
351                $blocs_exclus_import = array_column($contenu_import['pages_explicites'], 'blocs_exclus', 'page');
352                // -- on compare les pages de la base et celles de l'import et on met à jour systématiquement
353                //    les pages communes (même identifiant).
354                foreach ($pages_explicites_base as $_page_explicite) {
355                        if (isset($blocs_exclus_import[$_page_explicite['page']])) {
356                                // Remplacement des blocs exclus de la page actuelle par ceux du fichier d'import. On filtre
357                                // les blocs éventuellement non autorisés sur le site.
358                                $modification = array(
359                                        'blocs_exclus' => array_intersect($blocs_exclus_import[$_page_explicite['page']], $blocs_defaut)
360                                );
361                                $where = array('page=' . sql_quote($_page_explicite['page']));
362                                sql_updateq('spip_noizetier_pages', $modification, $where);
363                        }
364                }
365        }
366
367        // Les compositions virtuelles
368        if ($importation['compositions_virtuelles']) {
369                if ($importation['compositions_virtuelles'] == 'remplacer') {
370                        // On vide d'abord la table spip_noizetier_pages de toutes le compositions virtuelles du noiZetier.
371                        $where = array('est_virtuelle=' . sql_quote('oui'));
372                        if (!sql_delete('spip_noizetier_pages', $where)) {
373                                $retour = false;
374                        }
375                }
376
377                if ($retour) {
378                        // On collecte les compositions virtuelles actuellement en base.
379                        $select = array('page');
380                        $where = array('est_virtuelle=' . sql_quote('oui'));
381                        $compositions_base = sql_allfetsel($select, 'spip_noizetier_pages', $where);
382                        if ($compositions_base) {
383                                $compositions_base = array_map('reset', $compositions_base);
384                        }
385
386                        // Suivant le mode d'importation et l'existence ou pas de la composition en base on ajoute ou
387                        // on met à jour la composition virtuelle ou on ne fait rien.
388                        foreach ($contenu_import['compositions_virtuelles'] as $_composition) {
389                                // On filtre les blocs exclus avec la liste des blocs par défaut du site.
390                                $composition = $_composition;
391                                $composition['blocs_exclus'] = array_intersect($composition['blocs_exclus'], $blocs_defaut);
392
393                                // On détermine l'opération à faire ou pas.
394                                if (in_array($composition['page'], $compositions_base)) {
395                                        if ($importation['compositions_virtuelles'] == 'fusionner') {
396                                                $where = 'page=' . sql_quote($composition['page']);
397                                                unset($composition['page']);
398                                                sql_updateq('spip_noizetier_pages', $composition, $where);
399                                        }
400                                } else {
401                                        sql_insertq('spip_noizetier_pages', $composition);
402                                }
403                        }
404                }
405        }
406
407        // Les noisettes
408        if ($importation['noisettes']) {
409                if ($importation['noisettes'] == 'remplacer') {
410                        // On vide d'abord la table spip_noisettes de toutes les noisettes du noiZetier.
411                        $where = array('plugin=' . sql_quote('noizetier'));
412                        if (sql_delete('spip_noisettes', $where) === false) {
413                                $retour = false;
414                        }
415                }
416
417                if ($retour) {
418                        // Liste des pages génériques disponibles dans la base.
419                        $pages_base = sql_allfetsel('page','spip_noizetier_pages');
420                        $pages_base = array_map('reset', $pages_base);
421
422                        // Nombre de noisettes par conteneur. On récupère l'ensemble des conteneurs y compris les noisettes
423                        // conteneur mais seuls les blocs Z du noiZetier sont utiles.
424                        $select = array('id_conteneur', 'count(*) as nb_noisettes');
425                        $where = array('plugin=' . sql_quote('noizetier'));
426                        $group_by = array('id_conteneur');
427                        $nb_noisettes_base = sql_allfetsel($select, 'spip_noisettes', $where, $group_by);
428                        if ($nb_noisettes_base) {
429                                $nb_noisettes_base = array_column($nb_noisettes_base, 'nb_noisettes', 'id_conteneur');
430                        }
431
432                        // On insère les noisettes du fichier d'import appartenant à des pages ou des objets disponibles dans la
433                        // base. Dans le fichier d'export, les noisettes conteneur sont classées avant les autres noisettes et
434                        // suivant une profondeur croissante de façon à être créées quand les noisettes imbriquées le nécessiteront.
435                        // Cette opération se fait en deux passes pour gérer le fait que les noisettes conteneur vont
436                        // changer d'id ce qui change leur identifiant de conteneur :
437                        // - Passe 1 : si la noisette est à insérer on l'ajoute dans le conteneur sans se préoccuper du changement
438                        //             d'id de conteneur pour les noisettes conteneur. On stocke toutes les informations nécessaires
439                        //             à la passe 2 comme le nouvel id des noisettes conteneur.
440                        include_spip('base/objets');
441                        include_spip('inc/ncore_conteneur');
442                        include_spip('inc/ncore_noisette');
443                        $noisettes_conteneur = $noisettes_imbriquees = array();
444                        foreach ($contenu_import['noisettes'] as $_id_noisette_ancien => $_noisette) {
445                                // On vérifie qu'il faut bien importer la noisette
446                                $noisette_a_importer = false;
447                                if ($_noisette['type']) {
448                                        $page_import = $_noisette['composition']
449                                                ? $_noisette['type'] . '-' . $_noisette['composition']
450                                                : $_noisette['type'];
451                                        if (in_array($page_import, $pages_base)) {
452                                                $noisette_a_importer = true;
453                                        }
454                                } else {
455                                        $table_objet = table_objet_sql($_noisette['objet']);
456                                        $id_table_objet = id_table_objet($_noisette['objet']);
457                                        $where = array($id_table_objet. '=' . intval($_noisette['id_objet']));
458                                        if (sql_countsel($table_objet, $where)) {
459                                                $noisette_a_importer = true;
460                                        }
461                                }
462
463                                if ($noisette_a_importer) {
464                                        // La noisette à importer est bien associée à une page ou un objet de la base.
465                                        // Les noisettes ne sont pas triées dans l'ordre d'insertion pour un conteneur donné,
466                                        // il faut donc se baser sur le rang dans le fichier d'import. Pour une noisette appartenant à un
467                                        // conteneur noisette on reprend le rang tel que mais pour une noisette incluse dans un bloc Z il
468                                        // faut recalculer le rang en tenant compte des noisettes déjà incluses dans la base.
469                                        $rang = $_noisette['rang_noisette'];
470                                        $conteneur = unserialize($_noisette['conteneur']);
471                                        $conteneur_est_noisette = conteneur_est_noisette('noizetier', $conteneur);
472                                        if (!$conteneur_est_noisette) {
473                                                $rang_max = !empty($nb_noisettes_base[$_noisette['id_conteneur']])
474                                                        ? $nb_noisettes_base[$_noisette['id_conteneur']]
475                                                        : 0;
476                                                $rang += $rang_max;
477                                        }
478                                        $id_noisette_nouveau = noisette_ajouter(
479                                                'noizetier',
480                                                $_noisette['type_noisette'],
481                                                $conteneur,
482                                                $rang);
483                                        // La noisette a été ajoutée de façon générique (paramètres par défaut). Pour finaliser l'importation
484                                        // il faut aussi mettre à jour les données paramétrables : parametres, encapsulation et css.
485                                        if ($id_noisette_nouveau) {
486                                                $champs_modifiables = array('parametres');
487                                                if ($_noisette['est_conteneur'] != 'oui') {
488                                                        $champs_modifiables = array_merge($champs_modifiables, array('parametres', 'encapsulation', 'css'));
489                                                }
490                                                $modifications = array_intersect_key($_noisette, array_flip($champs_modifiables));
491                                                noisette_parametrer('noizetier', $id_noisette_nouveau, $modifications);
492                                        }
493
494                                        // Pour conclure il faut stocker les informations nécessaires à la passe suivante:
495                                        // - les noisettes imbriquées dans un conteneur noisette et les référence de ce conteneur
496                                        // - la nouvelle valeur de l'id_noisette des noisettes conteneur
497                                        if ($conteneur_est_noisette) {
498                                                // Il faut se rappeler de la noisette car il faudra changer son conteneur (2 champs) lors de la
499                                                // deuxième passe. On stocke
500                                                $noisettes_imbriquees[$id_noisette_nouveau] = array(
501                                                        'type_noisette' => $conteneur['type_noisette'],
502                                                        'id_noisette' => $conteneur['id_noisette']
503                                                );
504                                        }
505                                        if ($_noisette['est_conteneur'] == 'oui') {
506                                                // La noisette est un conteneur. On constitue un tableau permettant de calculer son nouvel
507                                                // identifiant induit par son nouvel id de noisette. Le tableau est indexé par son ancien id.
508                                                $noisettes_conteneur[$_id_noisette_ancien] = $id_noisette_nouveau;
509                                        }
510                                }
511                        }
512
513                        // - Passe 2 : On reprend les noisettes venant d'être insérées dans une noisette conteneur et
514                        //             on rétablit le bon conteneur (id et tableau sérialisé), la profondeur et les informations
515                        //             du bloc Z accueillant les noisettes.
516                        if ($noisettes_imbriquees) {
517                                foreach ($noisettes_imbriquees as $_id_noisette_nouveau => $_conteneur_ancien) {
518                                        // Détermination du conteneur
519                                        $nouveau_conteneur = $_conteneur_ancien;
520                                        $nouveau_conteneur['id_noisette'] = $noisettes_conteneur[$_conteneur_ancien['id_noisette']];
521
522                                        // Détermination de la profondeur et des caractéristiques du bloc Z de plus haut niveau.
523                                        // Le conteneur est une noisette, qui a été insérée précédemment, on la lit.
524                                        $select = array('type', 'composition', 'objet', 'id_objet',     'bloc', 'profondeur');
525                                        $where = array(
526                                                'id_noisette=' . intval($nouveau_conteneur['id_noisette']),
527                                                'plugin=' . sql_quote('noizetier')
528                                        );
529                                        $modifications = sql_fetsel($select, 'spip_noisettes', $where);
530
531                                        // On finalise les modifications
532                                        $modifications['profondeur'] += 1;
533                                        $modifications['conteneur'] = serialize($nouveau_conteneur);
534                                        $modifications['id_conteneur'] = conteneur_identifier('noizetier', $nouveau_conteneur);
535
536                                        // On met à jour le contenu de la noisette en base.
537                                        $where = array('plugin=' . sql_quote('noizetier'), 'id_noisette=' . intval($_id_noisette_nouveau));
538                                        sql_updateq('spip_noisettes', $modifications, $where);
539                                }
540                        }
541                }
542        }
543
544        // On invalide le cache
545        include_spip('inc/invalideur');
546        suivre_invalideur('noizetier-import-config');
547
548        return $retour;
549}
Note: See TracBrowser for help on using the repository browser.