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

Last change on this file was 113625, checked in by eric@…, 3 months ago

Par cohérence avec les autres API on rajoute l'argument $information en deuxème position de page_noizetier_lire() et par conséquence on revoit les appels (l'argument $traiter_typo est mis à false par défaut).
Et en plus on corrige la balise #PAGE_NOIZETIER_INFOS qui ne fonctionnait pas pour une demande d'information unique car justement l'API précédente ne le permettait pas !

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