source: spip-zone/_plugins_/noizetier/trunk/formulaires/editer_page.php @ 113481

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

Corriger le manque de redirection lors de la création d'une composition virtuelle

File size: 15.3 KB
RevLine 
[66152]1<?php
2
[93111]3if (!defined('_ECRIRE_INC_VERSION')) {
4        return;
5}
[66152]6
[104893]7// TODO : à quoi ça sert vraiment?
[93111]8if (!function_exists('autoriser')) {
9        include_spip('inc/autoriser');
10}     // si on utilise le formulaire dans le public
[66152]11
[91444]12/**
[93111]13 * Formulaire d'édition d'une page de composition de noisettes.
[91444]14 * Déclarer les champs postés et y intégrer les valeurs par défaut
15 *
[104670]16 * @param string $edition
17 *              Type d'édition à savoir :
18 *              - `modifier`: édition de la configuration de base d'une composition virtuelle
19 *              - `créer`: création d'une composition virtuelle à partir d'une page source
20 *              - `dupliquer`: copie d'une composition pour créer une nouvelle composition virtuelle
[105054]21 * @param string $page
22 *              L'identifiant de la page ou de la composition :
23 *              - `modifier`: la composition virtuelle en cours d'édition
24 *              - `créer`: la page source
25 *              - `dupliquer`: la composition source
[104670]26 * @param string $redirect
27 *              URL de redirection. La valeur dépend du type d'édition.
[91444]28 *
[104670]29 * @return array
30 *              Tableau des champs postés pour l'affichage du formulaire.
[91444]31 */
[105054]32function formulaires_editer_page_charger_dist($edition, $page, $redirect = '') {
[91444]33
[103269]34        // Initialisation des données communes à charger dans le formulaire
35        $valeurs = array(
36                'editable' => true,
37                'edition' => $edition,
38                'type_page' => '',
39                'composition' => '',
40                'nom' => '',
41                'description' => '',
42                'icon' => '',
[110344]43                'est_virtuelle' => 'oui',
[104517]44                '_blocs' => array(),
45                '_blocs_defaut' => array(),
[103269]46        );
[91444]47
[110110]48        include_spip('inc/noizetier_page');
[110112]49        $description_page = noizetier_page_lire($page, false);
[105054]50        if ($description_page) {
51                if ($edition == 'modifier') {
52                        // La page désignée par $page est déjà une composition virtuelle dont on souhaite modifier une
53                        // partie de la configuration (hors noisettes).
[110308]54                        // La variable $description_page contient donc la configuration complète de cette page.
[105054]55                        $valeurs['type_page'] = $description_page['type'];
56                        $valeurs['composition'] = $description_page['composition'];
[110308]57                        $valeurs['est_virtuelle'] = $description_page['est_virtuelle'];
[91444]58
[110308]59                        if ($valeurs['est_virtuelle'] == 'oui') {
60                                $valeurs['nom'] = $description_page['nom'];
61                                $valeurs['description'] = $description_page['description'];
62                                $valeurs['icon'] = $description_page['icon'];
63                        }
64
[105054]65                } elseif ($edition == 'dupliquer') {
66                        // La page désignée est la composition source que l'on souhaite dupliquer pour créer une nouvelle
67                        // composition virtuelle. La nouvelle composition virtuelle aura donc le même type de page et
68                        // un identifiant de composition différent initialisé à 'copie_composition'.
69                        // On initialise aussi le nom de la nouvelle composition à 'copie de nom_page_source'.
70                        $valeurs['type_page'] = $description_page['type'];
71                        $valeurs['composition'] = "copie_{$description_page['composition']}";
72                        $valeurs['nom'] = _T('noizetier:copie_de', array('source' => $description_page['nom']));
[91444]73
[105054]74                } elseif ($edition == 'creer') {
75                        // On crée une nouvelle composition à partir d'une page source.
[110308]76                        // La variable $description_page contient donc la configuration complète de la page source.
[105054]77                        $valeurs['type_page'] = $description_page['type'];
78                        $valeurs['nom'] = _T('info_sans_titre');
[104670]79
[105054]80                } else {
81                        $valeurs['editable'] = false;
82                }
[103269]83        } else {
84                $valeurs['editable'] = false;
[66152]85        }
[91444]86
[104517]87        if ($valeurs['editable']) {
[110110]88                // Ajout de la liste des blocs configurables afin de choisir de possibles exclusions.
[104670]89                // En outre, on initialise les blocs exclus par défaut qui coincident
90                // -- pour une modification, à la liste des blocs exclus de la composition en cours de modification
91                // -- pour une duplication ou une création de composition, à la liste des blocs exclus de la source.
92                // Ainsi cette liste est toujours l'inverse de l'index [blocs] de l'argument $description_page.
[110110]93                include_spip('inc/noizetier_bloc');
[110333]94                $blocs = noizetier_bloc_lister_defaut();
[110124]95                foreach ($blocs as $_bloc) {
96                        $valeurs['_blocs'][$_bloc] = noizetier_bloc_lire($_bloc, 'nom');
[104517]97                        if (!in_array($_bloc, $description_page['blocs'])) {
98                                $valeurs['_blocs_defaut'][] = $_bloc;
99                        }
100                }
[104670]101
102                // Ajout des héritages possibles en fonction du type de page. L'identifiant de la page permet quant à
103                // lui d'initialiser les héritages avec :
104                // - soit ceux de la page en cours de modification
105                // - soit ceux de la composition source pour une duplication
[110308]106                $valeurs['_heritiers'] = array();
107                if ($valeurs['est_virtuelle'] == 'oui') {
108                        $page = $description_page['composition']
109                                ? "{$description_page['type']}-{$description_page['composition']}"
110                                : '';
111                        $valeurs = array_merge($valeurs, construire_heritages($valeurs['type_page'], $page));
112                }
[104517]113        }
114
[66152]115        return $valeurs;
116}
117
[91444]118/**
[104893]119 * @param string $edition
120 *              Type d'édition à savoir :
121 *              - `modifier`: édition de la configuration de base d'une composition virtuelle
122 *              - `créer`: création d'une composition virtuelle à partir d'une page source
123 *              - `dupliquer`: copie d'une composition pour créer une nouvelle composition virtuelle
[105054]124 * @param string $page
125 *              L'identifiant de la page ou de la composition :
126 *              - `modifier`: la composition virtuelle en cours d'édition
127 *              - `créer`: la page source
128 *              - `dupliquer`: la composition source
[104670]129 * @param string $redirect
[104893]130 *              URL de redirection. La valeur dépend du type d'édition.
[91444]131 *
[104670]132 * @return array
[91444]133 */
[105054]134function formulaires_editer_page_verifier_dist($edition, $page, $redirect = '') {
[66152]135        $erreurs = array();
[104368]136
[104670]137        // On vérifie que les champs obligatoires ont été bien saisis
[110308]138        if (_request('est_virtuelle') == 'oui') {
139                foreach (array('type_page', 'composition', 'nom') as $champ) {
140                        if (!_request($champ)) {
141                                $erreurs[$champ] = _T('noizetier:formulaire_obligatoire');
142                        }
[93111]143                }
144        }
[104368]145
[104670]146        // On vérifie dans le cas d'une nouvelle composition que :
147        // - l'identifiant saisi n'est pas déjà utilisé par une autre composition
148        // - la syntaxe de l'identifiant qui ne doit contenir ni espace, ni tiret.
[104368]149        if ($edition != 'modifier') {
[113340]150                $composition = _request('composition');
151                // Identifiant libre
[66152]152                $type_page = _request('type_page');
[104960]153                $where = array('composition!=' . sql_quote(''));
154                $pages = sql_allfetsel('page', 'spip_noizetier_pages', $where);
155                if ($pages) {
[104893]156                        $pages = array_map('reset', $pages);
[104960]157                        if (isset($pages[$type_page.'-'.$composition])) {
158                                $erreurs['composition'] = _T('noizetier:formulaire_identifiant_deja_pris');
159                        }
[104893]160                }
[113340]161                // Syntaxe
162                if (!preg_match('#^[a-z0-9_]+$#', $composition)) {
163                        $erreurs['composition'] = _T('noizetier:formulaire_erreur_format_identifiant');
164                }
[66152]165        }
[93111]166
[66152]167        return $erreurs;
168}
169
[91444]170/**
[104893]171 *
172 *
173 * @param string $edition
174 *              Type d'édition à savoir :
[112598]175 *              - `modifier`: édition de la configuration de base d'une composition virtuelle ou des blocs exclus d'une page
[104893]176 *              - `créer`: création d'une composition virtuelle à partir d'une page source
177 *              - `dupliquer`: copie d'une composition pour créer une nouvelle composition virtuelle
[105054]178 * @param string $page
179 *              L'identifiant de la page ou de la composition :
[104670]180 * @param string $redirect
[104893]181 *              URL de redirection. La valeur dépend du type d'édition.
[91444]182 *
[104670]183 * @return array
[91444]184 */
[105054]185function formulaires_editer_page_traiter_dist($edition, $page, $redirect = '') {
[91444]186
[104368]187        $retour = array();
[104893]188        $description = array();
[104368]189
[110308]190        // Identifiant de la page ou de la composition.
[66152]191        $type_page = _request('type_page');
192        $composition = _request('composition');
[110308]193        $identifiant = $composition ? "${type_page}-${composition}" : $type_page;
[91444]194
[110308]195        // Déterminer si la page est explicite ou est une composition virtuelle.
196        // En effet, pour les pages explicites seuls les blocs exclus peuvent être modifiés.
197        $est_virtuelle = _request('est_virtuelle');
198
[104893]199        // Récupération des champs descriptifs et de l'icone.
[110308]200        if ($est_virtuelle == 'oui') {
201                $description['nom'] = _request('nom');
202                $description['description'] = _request('description');
203                $description['icon'] = _request('icon');
[91444]204
[110308]205                // Traitement des branches éventuelles pour la composition virtuelle résultante
206                $branche = array();
207                $heritages = construire_heritages($type_page);
208                foreach ($heritages['_heritiers'] as $_objet => $_composition) {
209                        if ($composition_heritee = _request("heritage-${_objet}")) {
210                                $branche[$_objet] = $composition_heritee;
211                        }
212                }
213                $description['branche'] = $branche;
214        }
215
[104368]216        // Traitement des blocs configurables
[104517]217        $blocs_exclus = _request('blocs_exclus');
[113190]218        if ($blocs_exclus == null) {
219                $blocs_exclus = array();
220        }
[104893]221        $description['blocs_exclus'] = $blocs_exclus;
222        // TODO : si on exclut des blocs il faut supprimer leurs éventuelles noisettes.
[110308]223        // TODO : une autre solution serait d'interdire l'exclusion d'un bloc contenant une noisette
[104368]224
[104893]225        if ($edition != 'modifier') {
226                // Initialisation de la description pour une composition virtuelle.
227                $description_defaut = array(
228                        'page'           => $identifiant,
229                        'type'           => $type_page,
230                        'composition'    => $composition,
231                        'nom'            => $identifiant,
232                        'description'    => '',
233                        'icon'           => 'page-24.png',
234                        'blocs_exclus'   => array(),
235                        'necessite'      => array(),
236                        'branche'        => array(),
237                        'est_virtuelle'  => 'oui',
238                        'est_page_objet' => 'non',
239                        'signature'      => '',
240                );
[91444]241
[104893]242                // Identifie si la page est celle d'un objet SPIP
243                include_spip('base/objets');
244                $tables_objets = array_keys(lister_tables_objets_sql());
245                $description['est_page_objet'] = in_array(table_objet_sql($type_page), $tables_objets) ? 'oui' : 'non';
246
247                // Complétude de la description avec les valeurs par défaut
248                $description = array_merge($description_defaut, $description);
249        }
250
251        // On termine en sérialisant les tableaux des blocs exclus, necessite et branche.
252        $description['blocs_exclus'] = serialize($description['blocs_exclus']);
[110308]253        if ($est_virtuelle == 'oui') {
254                $description['branche'] = serialize($description['branche']);
255                if (isset($description['necessite'])) {
256                        $description['necessite'] = serialize($description['necessite']);
257                }
[104893]258        }
259
[113120]260        // Mise à jour ou insertion de la composition virtuelle
[104893]261        if ($edition == 'modifier') {
[110308]262                // -- Update de la composition modifiée
[104893]263                $where = array('page=' . sql_quote($identifiant));
264                $retour_sql = sql_updateq('spip_noizetier_pages', $description, $where);
265        } else {
266                // -- Insertion de la nouvelle composition
267                $retour_sql = sql_insertq('spip_noizetier_pages', $description);
268
[104670]269                // Pour une création ou un duplication, il faut traiter le peuplement automatique des noisettes
270                // de la page source si requis.
271                // -- on préremplit avec les noisettes de la page source, systématiquement en cas de duplication
272                //    ou si demandé, en cas de création.
[113431]273                if ($retour_sql !== false) {
[104893]274                        if (($type_page != 'page')
275                        and (($edition == 'dupliquer') or (($edition == 'creer') and _request('peupler')))) {
[113431]276                                // Récupération des noisettes de la page source de profondeur 0, classées par bloc puis par rang.
277                                // En effet, la fonction de duplication gérera la récursivité (profondeur > 0) si besoin.
278                                include_spip('inc/noizetier_page');
279                                $select = array('id_noisette', 'rang_noisette', 'bloc');
[109831]280                                $from = 'spip_noisettes';
[110321]281                                $where = array(
282                                        'plugin=' . sql_quote('noizetier'),
[113431]283                                        'profondeur=0',
[110321]284                                        'type=' . sql_quote($type_page),
285                                        'composition=' . sql_quote(noizetier_page_extraire_composition($page))
286                                );
[113431]287                                $order_by = array('bloc', 'rang_noisette');
288                                $noisettes_source = sql_allfetsel($select, $from, $where, '', $order_by);
289                                // Injection des noisettes de la source dans la composition virtuelle en cours de création.
[104893]290                                if ($noisettes_source) {
[113431]291                                        $conteneur_destination = array();
292                                        include_spip('inc/ncore_noisette');
293                                        $parametrage = array('parametres', 'encapsulation', 'css');
294                                        foreach ($noisettes_source as $_noisette) {
295                                                // On calcule le nouveau conteneur sachant que l'identifiant de la page est déjà connu
296                                                // que le bloc doit être le même que celui de la noisette source et que le conteneur est forcément
297                                                // un squelette (pas un objet).
298                                                $conteneur_destination['squelette'] = $_noisette['bloc'] . '/' . $identifiant;
299                                                // On duplique la noisette source dans le conteneur de la composition virtuelle : le
300                                                // rang de la noisette source est conservé et le paramétrage entièrement copié
301                                                noisette_dupliquer(
302                                                        'noizetier',
303                                                        $_noisette['id_noisette'],
304                                                        $conteneur_destination,
305                                                        $_noisette['rang_noisette'],
306                                                        $parametrage
307                                                );
[104893]308                                        }
[104368]309                                }
[93111]310                        }
[104893]311
312                        // On invalide le cache en cas de création ou  de duplication
313                        include_spip('inc/invalideur');
314                        suivre_invalideur("id='page/$identifiant'");
[66152]315                }
316        }
[91444]317
[104893]318        if ($retour_sql === false) {
319                $retour['message_nok'] = _T('noizetier:formulaire_composition_erreur');
320        } else {
321                $retour['message_ok'] = _T('noizetier:formulaire_composition_mise_a_jour');
322                if (in_array($edition, array('creer', 'dupliquer'))) {
[113481]323                        // On redirige vers la page de la composition virtuelle venant d'être créée.
324                        $retour['redirect'] = parametre_url(generer_url_ecrire('noizetier_page'), 'page', $identifiant);
[104893]325                } elseif ($redirect) {
326                        if (strncmp($redirect, 'javascript:', 11) == 0) {
327                                $retour['message_ok'] .= '<script type="text/javascript">/*<![CDATA[*/'.substr($redirect, 11).'/*]]>*/</script>';
328                                $retour['editable'] = true;
329                        } else {
330                                $retour['redirect'] = $redirect;
331                        }
[66152]332                }
333        }
[91444]334
[104368]335        return $retour;
[66152]336}
[103269]337
338
[104670]339/**
340 * Détermine les compositions héritables par le type de page et les héritages définis
341 * pour chaque type d'objet concerné par la composition désignée par $page.
342 *
343 * @param string $type
344 *              Type d'objet pouvant posséder des enfants.
345 * @param string $page
346 *              Identifiant de la composition dont les héritages doivent être renvoyés.
347 *
348 * @return array
349 */
[104671]350function construire_heritages($type, $page = '') {
[104670]351
352        // Initialisation du tableau
[104217]353        $heritages = array('_heritiers' => array());
[103269]354
[104670]355        // Récupération des compositions explicites et virtuelles
[104894]356        $select = array('page', 'type', 'composition', 'nom', 'branche');
357        $where = array('composition!=' . sql_quote(''));
358        $compositions = sql_allfetsel($select, 'spip_noizetier_pages', $where);
359        if ($compositions) {
360                // On réindexe le tableau entier par l'identifiant de la page
361                $compositions = array_column($compositions, null, 'page');
[104670]362
[104894]363                // Récupération des types d'objet (objets héritiers) possédant un type d'objet parent.
364                // Par exemple, article qui à a un parent rubrique.
365                include_spip('compositions_fonctions');
366                $objets_heritiers = array_keys(compositions_recuperer_heritage(), $type);
367                if ($objets_heritiers) {
368                        foreach ($compositions as $_page => $_configuration) {
369                                // Pour chaque composition répertoriée par le noiZetier, on détecte si celle-ci est affectable à
370                                // un des types d'objet ayant un parent et on liste les compositions par objet héritier.
371                                if (in_array($_configuration['type'], $objets_heritiers)) {
372                                        if (empty($heritages['_heritiers'][$_configuration['type']]['-'])) {
373                                                // Ne pas oublier d'insérer une fois la page par défaut de l'objet
374                                                $heritages['_heritiers'][$_configuration['type']]['-'] =
375                                                        ucfirst(_T('compositions:composition_defaut')) . ' (' . $_configuration['type'] . ')';
[104670]376                                        }
[104894]377                                        $heritages['_heritiers'][$_configuration['type']][$_configuration['composition']] =
378                                                $_configuration['nom'] . ' (' . $_configuration['type'] . '-' . $_configuration['composition'] . ')';
379                                        // On initialise, pour la page concernée si besoin, la composition affectée.
380                                        if (($_page == $page) and ($branches = unserialize($_configuration['branche'])) and !empty($branches)) {
381                                                foreach ($branches as $_objet => $_composition) {
382                                                        $heritages["heritage-${_objet}"] = $_composition;
383                                                }
384                                        }
[104670]385                                }
[104217]386                        }
387                }
388        }
389
390        return $heritages;
[103269]391}
Note: See TracBrowser for help on using the repository browser.