source: spip-zone/_plugins_/taxonomie/trunk/taxonomie_ieconfig.php @ 113401

Last change on this file since 113401 was 113401, checked in by root, 4 months ago

Mise au point de l'export IEConfig qui permet de sauvegarder outre la configuration du plugin :

  • les taxons du règne au genre, importés via les fichiers ITIS puis édités manuellement;
  • les taxons ascendants d'une espèce (entre le genre et l'espèce non compris), non inclus dans un fichier ITIS et insérés lors de la création d'une espèce;
  • les taxons de type espèce et descendants créés manuellement.
  • Property svn:eol-style set to native
File size: 24.0 KB
Line 
1<?php
2
3if (!defined('_ECRIRE_INC_VERSION')) {
4        return;
5}
6
7/**
8 * Pipeline ieconfig pour l'import/export des données de configuration du plugin et de certaines données de production.
9 *
10 * @param array $flux
11 *
12 * @return array
13 */
14function taxonomie_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                //    de Taxonomie.
24                $saisies = array(
25                        array(
26                                'saisie' => 'fieldset',
27                                'options' => array(
28                                        'nom'   => 'taxonomie_fieldset',
29                                        'label' => '<:taxonomie:titre_page_taxonomie:>',
30                                        'icone' => 'taxon-16.png',
31                                ),
32                                'saisies' => array(
33                                        array(
34                                                'saisie' => 'oui_non',
35                                                'options' => array(
36                                                        'nom' => 'taxonomie_export_option',
37                                                        'label' => '<:taxonomie:ieconfig_taxonomie_export_option:>',
38                                                        'explication' => '<:taxonomie:ieconfig_taxonomie_export_explication:>',
39                                                        'defaut' => '',
40                                                ),
41                                        ),
42                                ),
43                        ),
44                );
45                $flux['data'] = array_merge($flux['data'], $saisies);
46
47        } elseif (($action == 'export') and (_request('taxonomie_export_option') == 'on')) {
48                // Générer le tableau d'export
49                $flux['data']['taxonomie'] = taxonomie_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 plugin Taxonomie contenant toujours sa configuration et les taxons nécessitant d'être
245 * sauvegardés car non créés via les fichiers ITIS.
246 * Les taxons concernés sont :
247 * - les taxons du règne au genre, importés via les fichiers ITIS puis édités manuellement;
248 * - les taxons ascendants d'une espèce (entre le genre et l'espèce non compris), non inclus dans un fichier ITIS
249 *   et insérés lors de la création d'une espèce;
250 * - les taxons de type espèce et descendants créés manuellement.
251 *
252 * @return array
253 *         Tableau d'export pour le pipeline ieconfig_exporter.
254 **/
255function taxonomie_ieconfig_exporter() {
256
257        $export = array();
258
259        // Insérer une en-tête qui permet de connaitre la version du plugin Taxonomie utilisé lors de l'export
260        $informer_plugin = chercher_filtre('info_plugin');
261        $export['version'] = $informer_plugin('taxonomie', 'version', true);
262        $export['schema'] = $informer_plugin('taxonomie', 'schema');
263        $export['contenu'] = array();
264
265        // Exportation de la configuration du plugin rangée dans la meta taxonomie uniquement.
266        // Etant donné que l'on utilise ce pipeline pour les données de production de Taxonomie, on exporte aussi
267        // sa configuration via ce pipeline et non via le pipeline ieconfig_metas.
268        include_spip('inc/config');
269        $export['configuration'] = lire_config('taxonomie');
270        $export['contenu']['configuration'] = $export['configuration'] ? 'on' : '';
271
272        // Les metas de chargement de chaque règne ne sont pas exportées mais on identifie quand même la liste des règnes
273        // insérés dans la base. Les taxons seront ensuite exportés par règne pour permettre un import plus ciblé.
274        include_spip('taxonomie_fonctions');
275        include_spip('inc/taxonomie');
276        $export['regnes'] = array();
277        $regnes = regne_lister();
278        foreach ($regnes as $_regne) {
279                if (regne_existe($_regne, $meta_regne)) {
280                        $export['regnes'][] = $_regne;
281                }
282        }
283        $export['contenu']['regnes'] = $export['regnes'] ? 'on' : '';
284
285        // Exportation de la table spip_taxons des taxons nécessitant d'être sauvegardés.
286        if ($export['contenu']['regnes']) {
287                // Récupération de la description de la table spip_taxons afin de connaitre la liste des colonnes.
288                include_spip('base/objets');
289                $from ='spip_taxons';
290                $description_table = lister_tables_objets_sql($from);
291                $select = array_diff(array_keys($description_table['field']), array('id_taxon', 'maj'));
292
293                // Pour faciliter l'import et aussi mieux le cibler les taxons exportés sont rangés par règne (index au nom
294                // du règne). Ensuite, on sépare aussi les taxons édités (index [taxons][edites]), les taxons créés en tant
295                // qu'ascendant d'une espèce (index [taxons][crees]) et les espèces créées manuellement (index [especes]).
296                foreach ($export['regnes'] as $_regne) {
297                        // Extraction des taxons du règne au genre édités manuellement par les utilisateurs ou créés lors d'un
298                        // ajout d'espèce.
299                        // On sauvegarde les champs éditables uniquement des édités et tous les champs pour les autres.
300                        $export[$_regne]['taxons'] = taxon_preserver($_regne);
301                        $export['contenu']['taxons']['edites'][$_regne] = $export[$_regne]['taxons']['edites'] ? 'on' : '';
302                        $export['contenu']['taxons']['crees'][$_regne] = $export[$_regne]['taxons']['crees'] ? 'on' : '';
303
304                        // Extraction des espèces et descendants.
305                        $export[$_regne]['especes'] = array();
306                        $where = array(
307                                'regne=' . sql_quote($_regne),
308                                'importe=' . sql_quote('non'),
309                                'espece=' . sql_quote('oui')
310                        );
311                        $export[$_regne]['especes'] = sql_allfetsel($select, $from, $where);
312                        $export['contenu']['especes'][$_regne] = $export[$_regne]['especes'] ? 'on' : '';
313                }
314        }
315
316        return $export;
317}
318
319/**
320 * Importe tout ou partie d'un fichier d'export ieconfig contenant les données du noiZetier.
321 *
322 * @param array $importation
323 *        Tableau associatif des demandes d'importation issues du formulaire ieconfig. Les index et les valeurs
324 *        possibles sont :
325 *        - `configuration` : vaut `on` pour importer ou null sinon
326 *        - `pages_explicites` : vaut `on` pour importer ou null sinon
327 *        - `compositions_virtuelles` : vaut `remplacer`, `ajouter` ou `fusionner` pour importer ou null sinon.
328 *        - `noisettes` : vaut `remplacer` ou `ajouter` pour importer ou null sinon.
329 * @param array $contenu_import
330 *        Tableau des données du noiZetier issues du fichier d'import.
331 *
332 * @return bool
333 */
334function taxonomie_ieconfig_importer($importation, $contenu_import) {
335
336        // Initialisation de la sortie
337        $retour = true;
338
339        // On appelle le pipeline pour éventuellement modifier le contenu à importer.
340        $contenu_import = pipeline('noizetier_config_import', $contenu_import);
341
342        // On récupère la liste des blocs par défaut des pages du site pour filtrer des blocs non autorisés
343        // provenant éventuellement de l'import. Cette liste sert pour les pages explicites et les compositions virtuelles.
344        include_spip('inc/noizetier_bloc');
345        $blocs_defaut = noizetier_bloc_lister_defaut();
346
347        // La configuration
348        if ($importation['configuration']) {
349                // On remplace la configuration actuelle par celle du fichier d'import.
350                include_spip('inc/config');
351                ecrire_config('noizetier', $contenu_import['configuration']);
352        }
353
354        // Les pages explicites
355        if ($importation['pages_explicites']) {
356                // On fusionne les blocs exclus de la configuration avec ceux des pages explicites de la base.
357                // -- On récupère toutes les pages de la base avec leur blocs exclus
358                $select = array('page', 'blocs_exclus');
359                $where = array('est_virtuelle=' . sql_quote('non'));
360                $pages_explicites_base = sql_allfetsel($select,'spip_noizetier_pages', $where);
361                // -- on structure les blocs exclus du fichier d'import sous la forme [page] = blocs exclus
362                $blocs_exclus_import = array_column($contenu_import['pages_explicites'], 'blocs_exclus', 'page');
363                // -- on compare les pages de la base et celles de l'import et on met à jour systématiquement
364                //    les pages communes (même identifiant).
365                foreach ($pages_explicites_base as $_page_explicite) {
366                        if (isset($blocs_exclus_import[$_page_explicite['page']])) {
367                                // Remplacement des blocs exclus de la page actuelle par ceux du fichier d'import. On filtre
368                                // les blocs éventuellement non autorisés sur le site.
369                                $modification = array(
370                                        'blocs_exclus' => array_intersect($blocs_exclus_import[$_page_explicite['page']], $blocs_defaut)
371                                );
372                                $where = array('page=' . sql_quote($_page_explicite['page']));
373                                sql_updateq('spip_noizetier_pages', $modification, $where);
374                        }
375                }
376        }
377
378        // Les compositions virtuelles
379        if ($importation['compositions_virtuelles']) {
380                if ($importation['compositions_virtuelles'] == 'remplacer') {
381                        // On vide d'abord la table spip_noizetier_pages de toutes le compositions virtuelles du noiZetier.
382                        $where = array('est_virtuelle=' . sql_quote('oui'));
383                        if (!sql_delete('spip_noizetier_pages', $where)) {
384                                $retour = false;
385                        }
386                }
387
388                if ($retour) {
389                        // On collecte les compositions virtuelles actuellement en base.
390                        $select = array('page');
391                        $where = array('est_virtuelle=' . sql_quote('oui'));
392                        $compositions_base = sql_allfetsel($select, 'spip_noizetier_pages', $where);
393                        if ($compositions_base) {
394                                $compositions_base = array_map('reset', $compositions_base);
395                        }
396
397                        // Suivant le mode d'importation et l'existence ou pas de la composition en base on ajoute ou
398                        // on met à jour la composition virtuelle ou on ne fait rien.
399                        foreach ($contenu_import['compositions_virtuelles'] as $_composition) {
400                                // On filtre les blocs exclus avec la liste des blocs par défaut du site.
401                                $composition = $_composition;
402                                $composition['blocs_exclus'] = array_intersect($composition['blocs_exclus'], $blocs_defaut);
403
404                                // On détermine l'opération à faire ou pas.
405                                if (in_array($composition['page'], $compositions_base)) {
406                                        if ($importation['compositions_virtuelles'] == 'fusionner') {
407                                                $where = 'page=' . sql_quote($composition['page']);
408                                                unset($composition['page']);
409                                                sql_updateq('spip_noizetier_pages', $composition, $where);
410                                        }
411                                } else {
412                                        sql_insertq('spip_noizetier_pages', $composition);
413                                }
414                        }
415                }
416        }
417
418        // Les noisettes
419        if ($importation['noisettes']) {
420                if ($importation['noisettes'] == 'remplacer') {
421                        // On vide d'abord la table spip_noisettes de toutes les noisettes du noiZetier.
422                        $where = array('plugin=' . sql_quote('noizetier'));
423                        if (sql_delete('spip_noisettes', $where) === false) {
424                                $retour = false;
425                        }
426                }
427
428                if ($retour) {
429                        // Liste des pages génériques disponibles dans la base.
430                        $pages_base = sql_allfetsel('page','spip_noizetier_pages');
431                        $pages_base = array_map('reset', $pages_base);
432
433                        // Nombre de noisettes par conteneur. On récupère l'ensemble des conteneurs y compris les noisettes
434                        // conteneur mais seuls les blocs Z du noiZetier sont utiles.
435                        $select = array('id_conteneur', 'count(*) as nb_noisettes');
436                        $where = array('plugin=' . sql_quote('noizetier'));
437                        $group_by = array('id_conteneur');
438                        $nb_noisettes_base = sql_allfetsel($select, 'spip_noisettes', $where, $group_by);
439                        if ($nb_noisettes_base) {
440                                $nb_noisettes_base = array_column($nb_noisettes_base, 'nb_noisettes', 'id_conteneur');
441                        }
442
443                        // On insère les noisettes du fichier d'import appartenant à des pages ou des objets disponibles dans la
444                        // base. Dans le fichier d'export, les noisettes conteneur sont classées avant les autres noisettes et
445                        // suivant une profondeur croissante de façon à être créées quand les noisettes imbriquées le nécessiteront.
446                        // Cette opération se fait en deux passes pour gérer le fait que les noisettes conteneur vont
447                        // changer d'id ce qui change leur identifiant de conteneur :
448                        // - Passe 1 : si la noisette est à insérer on l'ajoute dans le conteneur sans se préoccuper du changement
449                        //             d'id de conteneur pour les noisettes conteneur. On stocke toutes les informations nécessaires
450                        //             à la passe 2 comme le nouvel id des noisettes conteneur.
451                        include_spip('base/objets');
452                        include_spip('inc/ncore_conteneur');
453                        include_spip('inc/ncore_noisette');
454                        $noisettes_conteneur = $noisettes_imbriquees = array();
455                        foreach ($contenu_import['noisettes'] as $_id_noisette_ancien => $_noisette) {
456                                // On vérifie qu'il faut bien importer la noisette
457                                $noisette_a_importer = false;
458                                if ($_noisette['type']) {
459                                        $page_import = $_noisette['composition']
460                                                ? $_noisette['type'] . '-' . $_noisette['composition']
461                                                : $_noisette['type'];
462                                        if (in_array($page_import, $pages_base)) {
463                                                $noisette_a_importer = true;
464                                        }
465                                } else {
466                                        $table_objet = table_objet_sql($_noisette['objet']);
467                                        $id_table_objet = id_table_objet($_noisette['objet']);
468                                        $where = array($id_table_objet. '=' . intval($_noisette['id_objet']));
469                                        if (sql_countsel($table_objet, $where)) {
470                                                $noisette_a_importer = true;
471                                        }
472                                }
473
474                                if ($noisette_a_importer) {
475                                        // La noisette à importer est bien associée à une page ou un objet de la base.
476                                        // Les noisettes ne sont pas triées dans l'ordre d'insertion pour un conteneur donné,
477                                        // il faut donc se baser sur le rang dans le fichier d'import. Pour une noisette appartenant à un
478                                        // conteneur noisette on reprend le rang tel que mais pour une noisette incluse dans un bloc Z il
479                                        // faut recalculer le rang en tenant compte des noisettes déjà incluses dans la base.
480                                        $rang = $_noisette['rang_noisette'];
481                                        $conteneur = unserialize($_noisette['conteneur']);
482                                        $conteneur_est_noisette = conteneur_est_noisette('noizetier', $conteneur);
483                                        if (!$conteneur_est_noisette) {
484                                                $rang_max = !empty($nb_noisettes_base[$_noisette['id_conteneur']])
485                                                        ? $nb_noisettes_base[$_noisette['id_conteneur']]
486                                                        : 0;
487                                                $rang += $rang_max;
488                                        }
489                                        $id_noisette_nouveau = noisette_ajouter(
490                                                'noizetier',
491                                                $_noisette['type_noisette'],
492                                                $conteneur,
493                                                $rang);
494                                        // La noisette a été ajoutée de façon générique (paramètres par défaut). Pour finaliser l'importation
495                                        // il faut aussi mettre à jour les données paramétrables : parametres, encapsulation et css.
496                                        if ($id_noisette_nouveau) {
497                                                $champs_modifiables = array('parametres');
498                                                if ($_noisette['est_conteneur'] != 'oui') {
499                                                        $champs_modifiables = array_merge($champs_modifiables, array('parametres', 'encapsulation', 'css'));
500                                                }
501                                                $modifications = array_intersect_key($_noisette, array_flip($champs_modifiables));
502                                                noisette_parametrer('noizetier', $id_noisette_nouveau, $modifications);
503                                        }
504
505                                        // Pour conclure il faut stocker les informations nécessaires à la passe suivante:
506                                        // - les noisettes imbriquées dans un conteneur noisette et les référence de ce conteneur
507                                        // - la nouvelle valeur de l'id_noisette des noisettes conteneur
508                                        if ($conteneur_est_noisette) {
509                                                // Il faut se rappeler de la noisette car il faudra changer son conteneur (2 champs) lors de la
510                                                // deuxième passe. On stocke
511                                                $noisettes_imbriquees[$id_noisette_nouveau] = array(
512                                                        'type_noisette' => $conteneur['type_noisette'],
513                                                        'id_noisette' => $conteneur['id_noisette']
514                                                );
515                                        }
516                                        if ($_noisette['est_conteneur'] == 'oui') {
517                                                // La noisette est un conteneur. On constitue un tableau permettant de calculer son nouvel
518                                                // identifiant induit par son nouvel id de noisette. Le tableau est indexé par son ancien id.
519                                                $noisettes_conteneur[$_id_noisette_ancien] = $id_noisette_nouveau;
520                                        }
521                                }
522                        }
523
524                        // - Passe 2 : On reprend les noisettes venant d'être insérées dans une noisette conteneur et
525                        //             on rétablit le bon conteneur (id et tableau sérialisé), la profondeur et les informations
526                        //             du bloc Z accueillant les noisettes.
527                        if ($noisettes_imbriquees) {
528                                foreach ($noisettes_imbriquees as $_id_noisette_nouveau => $_conteneur_ancien) {
529                                        // Détermination du conteneur
530                                        $nouveau_conteneur = $_conteneur_ancien;
531                                        $nouveau_conteneur['id_noisette'] = $noisettes_conteneur[$_conteneur_ancien['id_noisette']];
532
533                                        // Détermination de la profondeur et des caractéristiques du bloc Z de plus haut niveau.
534                                        // Le conteneur est une noisette, qui a été insérée précédemment, on la lit.
535                                        $select = array('type', 'composition', 'objet', 'id_objet',     'bloc', 'profondeur');
536                                        $where = array(
537                                                'id_noisette=' . intval($nouveau_conteneur['id_noisette']),
538                                                'plugin=' . sql_quote('noizetier')
539                                        );
540                                        $modifications = sql_fetsel($select, 'spip_noisettes', $where);
541
542                                        // On finalise les modifications
543                                        $modifications['profondeur'] += 1;
544                                        $modifications['conteneur'] = serialize($nouveau_conteneur);
545                                        $modifications['id_conteneur'] = conteneur_identifier('noizetier', $nouveau_conteneur);
546
547                                        // On met à jour le contenu de la noisette en base.
548                                        $where = array('plugin=' . sql_quote('noizetier'), 'id_noisette=' . intval($_id_noisette_nouveau));
549                                        sql_updateq('spip_noisettes', $modifications, $where);
550                                }
551                        }
552                }
553        }
554
555        // On invalide le cache
556        include_spip('inc/invalideur');
557        suivre_invalideur('noizetier-import-config');
558
559        return $retour;
560}
Note: See TracBrowser for help on using the repository browser.