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

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

Correction de la gestion des blocs pour une composition virtuelle.
Passage d'un filtre en balise.

File size: 13.6 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                '_blocs' => array(),
44                '_blocs_defaut' => array(),
45        );
46
47        include_spip('inc/noizetier_page');
48        $description_page = noizetier_page_lire($page, false);
49        if ($description_page) {
50                if ($edition == 'modifier') {
51                        // La page désignée par $page est déjà une composition virtuelle dont on souhaite modifier une
52                        // partie de la configuration (hors noisettes).
53                        // L'argument $description_page contient donc la configuration complète de cette page.
54                        $valeurs['type_page'] = $description_page['type'];
55                        $valeurs['composition'] = $description_page['composition'];
56                        $valeurs['nom'] = $description_page['nom'];
57                        $valeurs['description'] = $description_page['description'];
58                        $valeurs['icon'] = $description_page['icon'];
59
60                } elseif ($edition == 'dupliquer') {
61                        // La page désignée est la composition source que l'on souhaite dupliquer pour créer une nouvelle
62                        // composition virtuelle. La nouvelle composition virtuelle aura donc le même type de page et
63                        // un identifiant de composition différent initialisé à 'copie_composition'.
64                        // On initialise aussi le nom de la nouvelle composition à 'copie de nom_page_source'.
65                        $valeurs['type_page'] = $description_page['type'];
66                        $valeurs['composition'] = "copie_{$description_page['composition']}";
67                        $valeurs['nom'] = _T('noizetier:copie_de', array('source' => $description_page['nom']));
68
69                } elseif ($edition == 'creer') {
70                        // On crée une nouvelle composition à partir d'une page source.
71                        // L'argument $description_page contient donc la configuration complète de la page source.
72                        $valeurs['type_page'] = $description_page['type'];
73                        $valeurs['nom'] = _T('info_sans_titre');
74
75                } else {
76                        $valeurs['editable'] = false;
77                }
78        } else {
79                $valeurs['editable'] = false;
80        }
81
82        if ($valeurs['editable']) {
83                // Ajout de la liste des blocs configurables afin de choisir de possibles exclusions.
84                // En outre, on initialise les blocs exclus par défaut qui coincident
85                // -- pour une modification, à la liste des blocs exclus de la composition en cours de modification
86                // -- pour une duplication ou une création de composition, à la liste des blocs exclus de la source.
87                // Ainsi cette liste est toujours l'inverse de l'index [blocs] de l'argument $description_page.
88                include_spip('inc/noizetier_bloc');
89                $blocs = noizetier_bloc_defaut();
90                foreach ($blocs as $_bloc) {
91                        $valeurs['_blocs'][$_bloc] = noizetier_bloc_lire($_bloc, 'nom');
92                        if (!in_array($_bloc, $description_page['blocs'])) {
93                                $valeurs['_blocs_defaut'][] = $_bloc;
94                        }
95                }
96
97                // Ajout des héritages possibles en fonction du type de page. L'identifiant de la page permet quant à
98                // lui d'initialiser les héritages avec :
99                // - soit ceux de la page en cours de modification
100                // - soit ceux de la composition source pour une duplication
101                $page = $description_page['composition']
102                        ? "{$description_page['type']}-{$description_page['composition']}"
103                        : '';
104                $valeurs = array_merge($valeurs, construire_heritages($valeurs['type_page'], $page));
105        }
106
107        return $valeurs;
108}
109
110/**
111 * @param string $edition
112 *              Type d'édition à savoir :
113 *              - `modifier`: édition de la configuration de base d'une composition virtuelle
114 *              - `créer`: création d'une composition virtuelle à partir d'une page source
115 *              - `dupliquer`: copie d'une composition pour créer une nouvelle composition virtuelle
116 * @param string $page
117 *              L'identifiant de la page ou de la composition :
118 *              - `modifier`: la composition virtuelle en cours d'édition
119 *              - `créer`: la page source
120 *              - `dupliquer`: la composition source
121 * @param string $redirect
122 *              URL de redirection. La valeur dépend du type d'édition.
123 *
124 * @return array
125 */
126function formulaires_editer_page_verifier_dist($edition, $page, $redirect = '') {
127        $erreurs = array();
128
129        // On vérifie que les champs obligatoires ont été bien saisis
130        foreach (array('type_page', 'composition', 'nom') as $champ) {
131                if (!_request($champ)) {
132                        $erreurs[$champ] = _T('noizetier:formulaire_obligatoire');
133                }
134        }
135
136        // On vérifie dans le cas d'une nouvelle composition que :
137        // - l'identifiant saisi n'est pas déjà utilisé par une autre composition
138        // - la syntaxe de l'identifiant qui ne doit contenir ni espace, ni tiret.
139        if ($edition != 'modifier') {
140                $type_page = _request('type_page');
141                $composition = _request('composition');
142
143                $where = array('composition!=' . sql_quote(''));
144                $pages = sql_allfetsel('page', 'spip_noizetier_pages', $where);
145                if ($pages) {
146                        $pages = array_map('reset', $pages);
147                        if (isset($pages[$type_page.'-'.$composition])) {
148                                $erreurs['composition'] = _T('noizetier:formulaire_identifiant_deja_pris');
149                        }
150                        if (!preg_match('#^[a-z0-9_]+$#', $composition)) {
151                                $erreurs['composition'] = _T('noizetier:formulaire_erreur_format_identifiant');
152                        }
153                }
154        }
155
156        return $erreurs;
157}
158
159/**
160 *
161 *
162 * @param string $edition
163 *              Type d'édition à savoir :
164 *              - `modifier`: édition de la configuration de base d'une composition virtuelle
165 *              - `créer`: création d'une composition virtuelle à partir d'une page source
166 *              - `dupliquer`: copie d'une composition pour créer une nouvelle composition virtuelle
167 * @param string $page
168 *              L'identifiant de la page ou de la composition :
169 *              - `modifier`: la composition virtuelle en cours d'édition
170 *              - `créer`: la page source
171 *              - `dupliquer`: la composition source
172 * @param string $redirect
173 *              URL de redirection. La valeur dépend du type d'édition.
174 *
175 * @return array
176 */
177function formulaires_editer_page_traiter_dist($edition, $page, $redirect = '') {
178
179        $retour = array();
180        $description = array();
181
182        // Identifiant de la composition résultante.
183        $type_page = _request('type_page');
184        $composition = _request('composition');
185        $identifiant = "${type_page}-${composition}";
186
187        // Récupération des champs descriptifs et de l'icone.
188        $description['nom'] = _request('nom');
189        $description['description'] = _request('description');
190        $description['icon'] = _request('icon');
191
192        // Traitement des blocs configurables
193        $blocs_exclus = _request('blocs_exclus');
194        $description['blocs_exclus'] = $blocs_exclus;
195        // TODO : si on exclut des blocs il faut supprimer leurs éventuelles noisettes.
196        // Une autre solution serait d'interdire l'exclusion d'un bloc contenant une noisette
197
198        // Traitement des branches éventuelles pour la composition virtuelle résultante
199        $branche = array();
200        $heritages = construire_heritages($type_page);
201        foreach ($heritages['_heritiers'] as $_objet => $_composition) {
202                if ($composition_heritee = _request("heritage-${_objet}")) {
203                        $branche[$_objet] = $composition_heritee;
204                }
205        }
206        $description['branche'] = $branche;
207
208        if ($edition != 'modifier') {
209                // Initialisation de la description pour une composition virtuelle.
210                $description_defaut = array(
211                        'page'           => $identifiant,
212                        'type'           => $type_page,
213                        'composition'    => $composition,
214                        'nom'            => $identifiant,
215                        'description'    => '',
216                        'icon'           => 'page-24.png',
217                        'blocs_exclus'   => array(),
218                        'necessite'      => array(),
219                        'branche'        => array(),
220                        'est_virtuelle'  => 'oui',
221                        'est_page_objet' => 'non',
222                        'signature'      => '',
223                );
224
225                // Identifie si la page est celle d'un objet SPIP
226                include_spip('base/objets');
227                $tables_objets = array_keys(lister_tables_objets_sql());
228                $description['est_page_objet'] = in_array(table_objet_sql($type_page), $tables_objets) ? 'oui' : 'non';
229
230                // Complétude de la description avec les valeurs par défaut
231                $description = array_merge($description_defaut, $description);
232        }
233
234        // On termine en sérialisant les tableaux des blocs exclus, necessite et branche.
235        $description['blocs_exclus'] = serialize($description['blocs_exclus']);
236        $description['branche'] = serialize($description['branche']);
237        if (isset($description['necessite'])) {
238                $description['necessite'] = serialize($description['necessite']);
239        }
240
241        // Mise ou insertion de la composition virtuelle
242        if ($edition == 'modifier') {
243                // -- Update de la compositon modifiée
244                $where = array('page=' . sql_quote($identifiant));
245                $retour_sql = sql_updateq('spip_noizetier_pages', $description, $where);
246        } else {
247                // -- Insertion de la nouvelle composition
248                $retour_sql = sql_insertq('spip_noizetier_pages', $description);
249
250                // Pour une création ou un duplication, il faut traiter le peuplement automatique des noisettes
251                // de la page source si requis.
252                // -- on préremplit avec les noisettes de la page source, systématiquement en cas de duplication
253                //    ou si demandé, en cas de création.
254                if ($retour_sql) {
255                        if (($type_page != 'page')
256                        and (($edition == 'dupliquer') or (($edition == 'creer') and _request('peupler')))) {
257                                // Récupération des noisettes de la page source
258                                $select = array('rang_noisette', 'type', 'composition', 'bloc', 'type_noisette', 'parametres');
259                                $from = 'spip_noisettes';
260                                $where = array('type=' . sql_quote($type_page), 'composition=' . sql_quote(noizetier_page_composition($page)));
261                                $noisettes_source = sql_allfetsel($select, $from, $where);
262                                // Injection des noisettes de la source dans la composition virtuelle en cours de création qui diffère
263                                // uniquement par l'identifiant de composition.
264                                if ($noisettes_source) {
265                                        foreach ($noisettes_source as $_index => $_noisette) {
266                                                $noisettes_source[$_index]['composition'] = $composition;
267                                        }
268                                        sql_insertq_multi($from, $noisettes_source);
269                                }
270                        }
271
272                        // On invalide le cache en cas de création ou  de duplication
273                        include_spip('inc/invalideur');
274                        suivre_invalideur("id='page/$identifiant'");
275                }
276        }
277
278        if ($retour_sql === false) {
279                $retour['message_nok'] = _T('noizetier:formulaire_composition_erreur');
280        } else {
281                $retour['message_ok'] = _T('noizetier:formulaire_composition_mise_a_jour');
282                if (in_array($edition, array('creer', 'dupliquer'))) {
283                        $retour['redirect'] = $redirect;
284                } elseif ($redirect) {
285                        if (strncmp($redirect, 'javascript:', 11) == 0) {
286                                $retour['message_ok'] .= '<script type="text/javascript">/*<![CDATA[*/'.substr($redirect, 11).'/*]]>*/</script>';
287                                $retour['editable'] = true;
288                        } else {
289                                $retour['redirect'] = $redirect;
290                        }
291                }
292        }
293
294        return $retour;
295}
296
297
298/**
299 * Détermine les compositions héritables par le type de page et les héritages définis
300 * pour chaque type d'objet concerné par la composition désignée par $page.
301 *
302 * @param string $type
303 *              Type d'objet pouvant posséder des enfants.
304 * @param string $page
305 *              Identifiant de la composition dont les héritages doivent être renvoyés.
306 *
307 * @return array
308 */
309function construire_heritages($type, $page = '') {
310
311        // Initialisation du tableau
312        $heritages = array('_heritiers' => array());
313
314        // Récupération des compositions explicites et virtuelles
315        $select = array('page', 'type', 'composition', 'nom', 'branche');
316        $where = array('composition!=' . sql_quote(''));
317        $compositions = sql_allfetsel($select, 'spip_noizetier_pages', $where);
318        if ($compositions) {
319                // On réindexe le tableau entier par l'identifiant de la page
320                $compositions = array_column($compositions, null, 'page');
321
322                // Récupération des types d'objet (objets héritiers) possédant un type d'objet parent.
323                // Par exemple, article qui à a un parent rubrique.
324                include_spip('compositions_fonctions');
325                $objets_heritiers = array_keys(compositions_recuperer_heritage(), $type);
326                if ($objets_heritiers) {
327                        foreach ($compositions as $_page => $_configuration) {
328                                // Pour chaque composition répertoriée par le noiZetier, on détecte si celle-ci est affectable à
329                                // un des types d'objet ayant un parent et on liste les compositions par objet héritier.
330                                if (in_array($_configuration['type'], $objets_heritiers)) {
331                                        if (empty($heritages['_heritiers'][$_configuration['type']]['-'])) {
332                                                // Ne pas oublier d'insérer une fois la page par défaut de l'objet
333                                                $heritages['_heritiers'][$_configuration['type']]['-'] =
334                                                        ucfirst(_T('compositions:composition_defaut')) . ' (' . $_configuration['type'] . ')';
335                                        }
336                                        $heritages['_heritiers'][$_configuration['type']][$_configuration['composition']] =
337                                                $_configuration['nom'] . ' (' . $_configuration['type'] . '-' . $_configuration['composition'] . ')';
338                                        // On initialise, pour la page concernée si besoin, la composition affectée.
339                                        if (($_page == $page) and ($branches = unserialize($_configuration['branche'])) and !empty($branches)) {
340                                                foreach ($branches as $_objet => $_composition) {
341                                                        $heritages["heritage-${_objet}"] = $_composition;
342                                                }
343                                        }
344                                }
345                        }
346                }
347        }
348
349        return $heritages;
350}
Note: See TracBrowser for help on using the repository browser.