source: spip-zone/_plugins_/ieconfig/trunk/formulaires/ieconfig_import.php @ 111305

Last change on this file since 111305 was 111305, checked in by riedel.nobuyuki@…, 12 months ago

Plus de print_r($option) qui n'aurait pas fait propre dans le cas d'une importation avec écrasement

File size: 11.7 KB
Line 
1<?php
2
3if (!defined('_ECRIRE_INC_VERSION')) {
4        return;
5}
6
7function ieconfig_saisies_import() {
8        // Etape de selection du fichier
9        if (!_request('_code_yaml') or _request('annuler') or _request('importer')) {
10                $saisies = array(
11                        array(
12                                'saisie' => 'fieldset',
13                                'options' => array(
14                                        'nom' => 'ieconfig_import_choix_fichier',
15                                        'label' => '<:ieconfig:label_ieconfig_import_choix_fichier:>',
16                                        'icone' => 'img/ieconfig-import.png',
17                                ),
18                                'saisies' => array(
19                                        array(
20                                                'saisie' => 'input',
21                                                'options' => array(
22                                                        'type' => 'file',
23                                                        'nom' => 'ieconfig_import_fichier',
24                                                        'label' => '<:ieconfig:label_ieconfig_import_fichier:>',
25                                                        'explication' => '<:ieconfig:explication_ieconfig_import_fichier:>',
26                                                ),
27                                        ),
28                                        array(
29                                                'saisie' => 'selection',
30                                                'options' => array(
31                                                        'type' => 'selection',
32                                                        'nom' => 'ieconfig_import_local',
33                                                        'label' => '<:ieconfig:label_ieconfig_import_local:>',
34                                                        'explication' => '<:ieconfig:explication_ieconfig_import_local:>',
35                                                        'datas' => ieconfig_config_locales(),
36                                                ),
37                                        ),
38                                ),
39                        ),
40                );
41                // Options d'importations
42        } else {
43                include_spip('inc/yaml');
44                $config = yaml_decode(_request('_code_yaml'));
45                $texte_explication = '<b>' . _T('ieconfig:texte_nom') . '</b> ' . _T_ou_typo($config['nom']);
46                if ($config['description'] != '') {
47                        $texte_explication .= '<br /><b>' . _T('ieconfig:texte_description') . '</b> ' . _T_ou_typo($config['description']);
48                }
49                // On identifie les entrées ne correspondant pas à un plugin
50                // Ou bien non déclarées dans ieconfig_metas
51                // Convention : les clés du tableau de config correspondent aux préfixes des plugins
52                $entrees = $config;
53                unset($entrees['nom']);
54                unset($entrees['description']);
55                unset($entrees['necessite']);
56                $entrees = array_map('strtolower', array_keys($entrees));
57                $plugins = array_map('strtolower', array_keys(unserialize($GLOBALS['meta']['plugin'])));
58                $entrees_prises_en_charge = array_merge(array_keys(pipeline('ieconfig_metas', array())), $plugins);
59                $plugins_manquants = array_diff($entrees, $entrees_prises_en_charge);
60                if (count($plugins_manquants) > 0) {
61                        $texte_explication .= '<p class="reponse_formulaire reponse_formulaire_erreur">' . _T('ieconfig:texte_plugins_manquants', array('plugins' => implode(', ', $plugins_manquants))) . '</p>';
62                }
63
64                $saisies = array(
65                        array(
66                                'saisie' => 'explication',
67                                'options' => array(
68                                        'nom' => 'import_details',
69                                        'texte' => $texte_explication,
70                                ),
71                        ),
72                );
73
74                // Gestion des plugins utilisant le pipeline ieconfig_metas
75                $ieconfig_metas = array();
76                foreach (pipeline('ieconfig_metas', array()) as $prefixe => $data) {
77                        if (isset($config[$prefixe])) {
78                                if (isset($data['icone'])) {
79                                        $icone = chemin_image($data['icone']);
80                                        if (!$icone) {
81                                                $icone = find_in_path($data['icone']);
82                                        }
83                                } else {
84                                        $icone = 'config-export-16.png';
85                                }
86                                $ieconfig_metas[$prefixe] = $prefixe;
87                                $saisies[] = array(
88                                'saisie' => 'fieldset',
89                                'options' => array(
90                                        'nom' => 'metas_fieldset',
91                                        'label' => $prefixe,
92                                        'icone' => $icone,
93                                        ),
94                                'saisies' => array ( 
95                                        array(
96                                                'saisie' => 'radio',
97                                                'options' => array(
98                                                        'nom' => $prefixe,
99                                                        'label' => '<:ieconfig:ieconfig_import:>',
100                                                        'datas' => array(
101                                                                'rien' => '<:ieconfig:ieconfig_import_rien:>',
102                                                                'fusion' => '<:ieconfig:ieconfig_import_fusionner:>',
103                                                                'ecrase' => '<:ieconfig:ieconfig_import_ecraser:>',
104                                                                'fusion_inv' => '<:ieconfig:ieconfig_import_fusionner_inv:>',                                           
105                                                                ),
106                                                        'defaut' => 'fusion',
107                                                        )
108                                                )
109                                        )
110                                );
111                        }
112                }
113               
114                // On passe via le pipeline ieconfig
115                $saisies = pipeline('ieconfig', array(
116                        'args' => array(
117                                'action' => 'form_import',
118                                'config' => $config,
119                        ),
120                        'data' => $saisies,
121                ));
122        }
123        return $saisies;
124}
125
126function formulaires_ieconfig_import_charger_dist() {
127        include_spip('inc/saisies');
128        $saisies = ieconfig_saisies_import();
129        $contexte = array(
130                '_saisies' => $saisies,
131        );
132        if (_request('_code_yaml') and !_request('annuler') and !_request('importer')) {
133                $contexte['_code_yaml'] = _request('_code_yaml');
134        }
135
136        return array_merge(saisies_charger_champs($saisies), $contexte);
137}
138
139function formulaires_ieconfig_import_verifier_dist() {
140        $erreurs = array();
141        // Etape de selection du fichier
142        if (!_request('_code_yaml')) {
143                // On a rien transmis et pas de fichier local
144                if (!_request('ieconfig_import_local') and $_FILES['ieconfig_import_fichier']['name'] == '') {
145                        $erreurs['message_erreur'] = _T('ieconfig:message_erreur_fichier_import_manquant');
146                }
147        } // Options d'import
148        else {
149                include_spip('inc/saisies');
150                $erreurs = saisies_verifier(ieconfig_saisies_import());
151        }
152
153        return $erreurs;
154}
155
156function formulaires_ieconfig_import_traiter_dist() {
157
158        include_spip('inc/config');
159        // Si on est à l'étape de sélection d'un fichier de configuration
160        // On place le code YAML dans le contexte
161        if (!_request('_code_yaml')) {
162                if ($_FILES['ieconfig_import_fichier']['name'] != '') {
163                        $dir = sous_repertoire(_DIR_TMP, 'ieconfig');
164                        $hash = md5('ieimport-' . $GLOBALS['visiteur_session']['id_auteur'] . time());
165                        $fichier = $dir . $hash . '-' . $_FILES['ieconfig_import_fichier']['name'];
166                        move_uploaded_file($_FILES['ieconfig_import_fichier']['tmp_name'], $fichier);
167                        lire_fichier($fichier, $code_yaml);
168                        @unlink($fichier);
169                } else {
170                        $fichier = _request('ieconfig_import_local');
171                        lire_fichier($fichier, $code_yaml);
172                }
173                set_request('_code_yaml', $code_yaml);
174        } // Si on valide l'import
175        elseif (_request('importer') && _request('_code_yaml')) {
176                include_spip('inc/yaml');
177                $config = yaml_decode(_request('_code_yaml'));
178
179                // On passe via le pipeline ieconfig
180                $message_erreur = pipeline('ieconfig', array(
181                        'args' => array(
182                                'action' => 'import',
183                                'config' => $config,
184                        ),
185                        'data' => '',
186                ));
187
188                // Gestion des plugins utilisant le pipeline ieconfig_metas
189                foreach (pipeline('ieconfig_metas', array()) as $prefixe => $data) {                   
190                        $option = _request($prefixe);
191
192                        //Si on veut une importation avec écrasement
193                        if ($option === 'ecrase') {
194                               
195                                if (isset($data['metas_brutes'])) {
196                                        foreach (explode(',', $data['metas_brutes']) as $meta) {
197                                                // On teste le cas ou un prefixe est indique (dernier caractere est *)
198                                                if (substr($meta, -1) == '*') {
199                                                        $p = substr($meta, 0, -1);
200                                                        foreach ($config[$prefixe] as $m => $v) {
201                                                                if (substr($m, 0, strlen($p)) == $p) {
202                                                                        ecrire_config($m . '/', $v);
203                                                                }
204                                                        }
205                                                } elseif (isset($config[$prefixe][$meta])) {
206                                                        ecrire_config($meta . '/', $config[$prefixe][$meta]);
207                                                }
208                                        }
209                                }
210                                if (isset($data['metas_serialize'])) {
211                                        foreach (explode(',', $data['metas_serialize']) as $meta) {
212                                                // On teste le cas ou un prefixe est indique (dernier caractere est *)
213                                                if (substr($meta, -1) == '*') {
214                                                        $p = substr($meta, 0, -1);
215                                                        foreach ($config[$prefixe] as $m => $v) {
216                                                                if (substr($m, 0, strlen($p)) == $p) {
217                                                                        ecrire_config($m . '/', serialize($v));
218                                                                }
219                                                        }
220                                                } elseif (isset($config[$prefixe][$meta])) {
221                                                        ecrire_config($meta . '/', serialize($config[$prefixe][$meta]));
222                                                }
223                                        }
224                                }
225                        }
226                        //Si on veut une importation avec fusion
227                        if ($option === 'fusion') {
228                               
229                                if (isset($data['metas_brutes'])) {
230                                        foreach (explode(',', $data['metas_brutes']) as $meta) {
231                                                // On teste le cas ou un prefixe est indique (dernier caractere est *)
232                                                if (substr($meta, -1) == '*') {
233                                                        $p = substr($meta, 0, -1);
234                                                        foreach ($config[$prefixe] as $m => $v) {
235                                                                if (substr($m, 0, strlen($p)) == $p) {
236                                                                        $save = lire_config($m . '/', $v);
237                                                                        $import = ($v);
238                                                                        $import = array_merge($save,$import);
239                                                                        ecrire_config($m . '/', $v);
240                                                                }
241                                                        }
242                                                } elseif (isset($config[$prefixe][$meta])) {
243                                                        $save = lire_config($meta . '/', $config[$prefixe][$meta]);
244                                                        $import = ($config[$prefixe][$meta]);                                                   
245                                                        $import = array_merge($save,$import);
246                                                        ecrire_config($meta . '/', $import);
247                                                }
248                                        }
249                                }
250                                if (isset($data['metas_serialize'])) {
251                                        foreach (explode(',', $data['metas_serialize']) as $meta) {
252                                                // On teste le cas ou un prefixe est indique (dernier caractere est *)
253                                                if (substr($meta, -1) == '*') {
254                                                        $p = substr($meta, 0, -1);
255                                                        foreach ($config[$prefixe] as $m => $v) {
256                                                                if (substr($m, 0, strlen($p)) == $p) {
257                                                                        $save = lire_config($m . '/', serialize($v));
258                                                                        $import = ($v);
259                                                                        $import = array_merge($save,$import);
260                                                                        ecrire_config($m . '/', serialize($import));                           
261                                                                }
262                                                        }
263                                                } elseif (isset($config[$prefixe][$meta])) {
264                                                        $save = lire_config($meta . '/', serialize($config[$prefixe][$meta]));
265                                                        $import = ($config[$prefixe][$meta]);
266                                                        $import = array_merge($save,$import);
267                                                        ecrire_config($meta . '/', serialize($import));
268                                                }
269                                        }
270                                }
271                        }
272                        //Si on veut une importation avec fusion_inv
273                        if ($option === 'fusion_inv') {
274
275                                if (isset($data['metas_brutes'])) {
276                                        foreach (explode(',', $data['metas_brutes']) as $meta) {
277                                                // On teste le cas ou un prefixe est indique (dernier caractere est *)
278                                                if (substr($meta, -1) == '*') {
279                                                        $p = substr($meta, 0, -1);
280                                                        foreach ($config[$prefixe] as $m => $v) {
281                                                                if (substr($m, 0, strlen($p)) == $p) {
282                                                                        $save = lire_config($m . '/', $v);
283                                                                        $import = ($v);
284                                                                        $import = array_merge($import,$save);
285                                                                        ecrire_config($m . '/', $import);
286                                                                }
287                                                        }
288                                                } elseif (isset($config[$prefixe][$meta])) {
289                                                        $save = lire_config($meta . '/', $config[$prefixe][$meta]);
290                                                        $import = ($config[$prefixe][$meta]);                                                   
291                                                        $import = array_merge($import,$save);
292                                                        ecrire_config($meta . '/', $import);
293                                                }
294                                        }
295                                }
296                                if (isset($data['metas_serialize'])) {
297                                        foreach (explode(',', $data['metas_serialize']) as $meta) {
298                                                // On teste le cas ou un prefixe est indique (dernier caractere est *)
299                                                if (substr($meta, -1) == '*') {
300                                                        $p = substr($meta, 0, -1);
301                                                        foreach ($config[$prefixe] as $m => $v) {
302                                                                if (substr($m, 0, strlen($p)) == $p) {
303                                                                        $save = lire_config($m . '/', serialize($v));
304                                                                        $import = ($v);
305                                                                        $import = array_merge($import,$save);
306                                                                        ecrire_config($m . '/', serialize($import));
307                                                                }
308                                                        }
309                                                } elseif (isset($config[$prefixe][$meta])) {
310                                                        $save = lire_config($meta . '/', serialize($config[$prefixe][$meta]));
311                                                        $import = ($config[$prefixe][$meta]);
312                                                        $import = array_merge($import,$save);
313                                                        ecrire_config($meta . '/', serialize($import));
314                                                }
315                                        }
316                                }
317                        }
318                }
319
320                if ($message_erreur != '') {
321                        return array('message_erreur' => $message_erreur);
322                } else {
323                        return array('message_ok' => _T('ieconfig:message_ok_import'));
324                }
325        }
326}
327
328// Renvoie la liste des fichiers de configurations présents dans un sous-répertoires ieconfig/
329function ieconfig_config_locales() {
330        static $liste_config = null;
331
332        if (is_null($liste_config)) {
333                include_spip('inc/yaml');
334                $liste_config = array();
335                $match = '.+[.]yaml$';
336                foreach (array_merge(find_all_in_path('ieconfig/', $match), find_all_in_path(_DIR_TMP . 'ieconfig/', $match)) as $fichier => $chemin) {
337                        $config = yaml_decode_file($chemin);
338                        // On regarde s'il y a un necessite
339                        $ok = true;
340                        if (isset($config['necessite'])) {
341                                if (!is_array($config['necessite'])) {
342                                        $config['necessite'] = array($config['necessite']);
343                                }
344                                foreach ($config['necessite'] as $plugin) {
345                                        if (!defined('_DIR_PLUGIN_' . strtoupper($plugin))) {
346                                                $ok = false;
347                                        }
348                                }
349                        }
350                        //on vérifie s'il y a un champs nom
351                        if ($ok) {
352                                if (isset($config['nom'])) {
353                                        $liste_config[$chemin] = _T_ou_typo($config['nom']);
354                                } else {
355                                        $liste_config[$chemin] = $fichier;
356                                }
357                        }
358                }
359        }
360
361        return $liste_config;
362}
Note: See TracBrowser for help on using the repository browser.