source: spip-zone/_plugins_/mots_arborescents/trunk/motsar_pipelines.php @ 91802

Last change on this file since 91802 was 91802, checked in by marcimat@…, 4 years ago

Correction d'un certain nombre de bugs :

  • ne pas afficher le sélecteur de mot parent si le groupe choisit ne le permet pas
  • ne pas pouvoir modifier le groupe de mot si un mot parent est défini
  • bien propager les modifications sur les mots d'un groupe lors de la modification de la configuration mots_arborescents d'un groupe de mot
File size: 13.4 KB
Line 
1<?php
2/**
3 * Utilisations de pipelines par Mots arborescents
4 *
5 * @plugin     Mots arborescents
6 * @copyright  2015
7 * @author     Matthieu Marcillaud
8 * @licence    GNU/GPL
9 * @package    SPIP\Motsar\Pipelines
10 */
11
12if (!defined('_ECRIRE_INC_VERSION')) return;
13
14
15/**
16 * Ajoute la liste des sous mots et un bouton de création de
17 * sous mot sur la vue d'un mot.
18 *
19 * @pipeline afficher_complement_objet
20 * @param array $flux
21 *     Données du pipeline
22 * @return array
23 *     Données du pipeline complétées
24**/
25function motsar_afficher_complement_objet($flux) {
26        // sur la vue d'un mot
27        if ($flux['args']['type'] == 'mot' and $id_mot = $flux['args']['id']) {
28                // completer la vue avec les informations des mots enfants
29                $id_groupe = sql_getfetsel('id_groupe', 'spip_mots', 'id_mot='. intval($id_mot));
30                if ($id_groupe) {
31                        $conf_arborescente = sql_getfetsel('mots_arborescents', 'spip_groupes_mots', 'id_groupe=' . $id_groupe);
32                        if ($conf_arborescente == 'oui') {
33                                $flux['data'] .= recuperer_fond("prive/squelettes/contenu/inc-mots", array('id_parent' => $id_mot, 'id_groupe' => $id_groupe), "ajax");
34                        }
35                }
36        }
37        return $flux;
38}
39
40/**
41 * Ajoute un commentaire si un groupe de mot accepte des mots arborescents
42 * sur la vue d'un groupe
43 *
44 * @pipeline afficher_fiche_objet
45 * @param array $flux
46 *     Données du pipeline
47 * @return array
48 *     Données du pipeline complétées
49**/
50function motsar_afficher_contenu_objet($flux) {
51        // sur la vue d'un groupe de mots
52        if ($flux['args']['type'] == 'groupe_mots') {
53                $id_objet = $flux['args']['id_objet'];
54                $mots_arborescents = sql_getfetsel('mots_arborescents', 'spip_groupes_mots', 'id_groupe=' . $id_objet);
55                if ($mots_arborescents == 'oui') {
56                        // completer la vue avec l'information d'arborescence
57                        $cherche = "/(<\/div>\s*<div class=\"groupe_mots-qui\">)/is";
58                        if (preg_match($cherche, $flux['data'], $m)) {
59                                $texte = "<div class='champ contenu_mots_arborescents'>\n"
60                                                . "\t<div class='label'>" . _T('motsar:option_autoriser_mots_arborescents') . "</div>\n"
61                                                . "\t<div dir='" . lang_dir() . "' class='mots_arborescents'>" . _T('motsar:option_autoriser_mots_arborescents') . "</div>\n"
62                                                . "</div>\n";
63                                $flux['data'] = preg_replace($cherche, $texte.'$1', $flux['data'], 1);
64                        }
65                }
66        }
67        return $flux;
68}
69
70
71/**
72 * Ajoute le parent dans l'environnement d'un nouveau mot, s'il est connu
73 *
74 * @pipeline formulaire_charger
75 * @param array $flux
76 *              Données du pipeline
77 * @return array
78 *              Données du pipeline complétées
79**/
80function motsar_formulaire_charger($flux) {
81        // sur le formulaire d'édition de groupe de mot
82        if ($flux['args']['form'] == 'editer_mot') {
83                // si c'est un nouveau mot
84                if ($flux['data']['id_mot'] == 'oui') {
85                        // le parent est dans l'url ?
86                        if ($id_parent = _request('id_parent')) {
87                                $flux['data']['id_parent'] = $id_parent;
88                        }
89                }
90        }
91        return $flux;
92}
93
94
95/**
96 * Verifie différentes choses sur le formulaire d'édition d'un mot.
97 *
98 * - vérifie que le parent d'un mot n'est pas ce mot lui-même !
99 * - empêche de pouvoir modifier d'un même coup ET le mot parent ET le groupe parent
100 *
101 * @pipeline formulaire_verifier
102 * @param array $flux
103 *     Données du pipeline
104 * @return array
105 *     Données du pipeline complétées
106**/
107function motsar_formulaire_verifier($flux) {
108        // sur le formulaire d'édition de groupe de mot
109        if ($flux['args']['form'] == 'editer_mot') {
110
111                // tester que le parent ne vaut pas le groupe
112                // ça ne devrait pas pouvoir arriver, car la saisie met ces options en disabled
113                if ($id_parent = _request('id_parent') and $id_mot = _request('id_mot')) {
114                        include_spip('motsar_fonctions'); // calcul_branche_mot_in
115                        if ($id_parent == $id_mot) {
116                                $flux['data']['id_parent'] = _T('motsar:erreur_parent_sur_mot');
117                        } elseif (in_array($id_parent, explode(',', calcul_branche_mot_in($id_mot)))) {
118                                $flux['data']['id_parent'] = _T('motsar:erreur_parent_sur_mot_enfant');
119                        }
120                }
121
122                // tester que le parent appartient au groupe sélectionné
123                if ($id_parent = _request('id_parent') and $id_groupe = _request('id_groupe')) {
124                        $id_groupe_parent = sql_getfetsel('id_groupe', 'spip_mots', 'id_mot=' . intval($id_parent));
125                        if ($id_groupe_parent != $id_groupe) {
126                                set_request('id_groupe', null);
127                                $flux['data']['id_parent'] = _T('motsar:erreur_parent_hors_groupe_selectionne');
128                                $flux['data']['id_groupe'] = _T('motsar:erreur_groupe_selectionne_annule');
129                        }
130                }
131        }
132        return $flux;
133}
134
135
136
137
138/**
139 * Modifie les champs du formulaire de groupe de mot et de mots
140 *
141 * Sur les mots :
142 * - ajouter le sélecteur de parenté
143 *
144 * Sur les groupes :
145 * - proposer l'option mots_arborescents
146 *
147 * @pipeline formulaire_fond
148 * @param array $flux
149 *              Données du pipeline
150 * @return array
151 *              Données du pipeline complétées
152**/
153function motsar_formulaire_fond($flux) {
154        if (!in_array($flux['args']['form'], array('editer_groupe_mot', 'editer_mot'))) {
155                return $flux;
156        }
157
158        $env = $flux['args']['contexte'];
159
160        // sur le formulaire d'édition de mot
161        // mais seulement si le groupe de mot choisi permet l'arborescence.
162        if ($flux['args']['form'] == 'editer_mot' and isset($env['id_groupe'])) {
163                $mots_arborescents = sql_getfetsel('mots_arborescents', 'spip_groupes_mots', 'id_groupe=' . intval($env['id_groupe']));
164                if ($mots_arborescents == 'oui') {
165                        // la parenté sur tous : on récupère le sélecteur et on l'ajoute après le titre...
166                        $selecteur_parent = recuperer_fond('formulaires/selecteur_mot_parent', $env);
167
168                        $cherche = "/(<(li|div)[^>]*class=(?:'|\")editer editer_titre.*?<\/\\2>)\s*(<(li|div)[^>]*class=(?:'|\")editer)/is";
169                        if (preg_match($cherche, $flux['data'], $m)) {
170                                $flux['data'] = preg_replace($cherche, '$1'.$selecteur_parent.'$3', $flux['data'], 1);
171                        }
172                }
173        }
174
175        // sur le formulaire d'édition de mot
176        elseif ($flux['args']['form'] == 'editer_groupe_mot') {
177                // l'option oui/non technique pour autoriser les mots_arborescents
178                $option_mots_arborescents = recuperer_fond('formulaires/option_mots_arborescents', $env);
179
180                $cherche = "/(<(li|div)[^>]*class=(?:'|\")editer editer_groupe_mots_reglage_avance.*?<\/\\2>)\s*(<(li|div)[^>]*class=(?:'|\")editer)/is";
181                if (preg_match($cherche, $flux['data'], $m)) {
182                        $flux['data'] = preg_replace($cherche, '$1'.$option_mots_arborescents.'$3', $flux['data'], 1);
183                }
184        }
185
186        return $flux;
187}
188
189/**
190 * Modifie les champs du formulaire de groupe de mot et de mots
191 *
192 * Sur les mots :
193 * - ajouter le sélecteur de parenté
194 *
195 * Sur les groupes :
196 * - proposer l'option mots_arborescents
197 *
198 * @pipeline formulaire_fond
199 * @note
200 *     Code utilisant querypath (mais non fonctionnel avec libxml version 2.9.2 :/)
201 *
202 * @param array $flux
203 *              Données du pipeline
204 * @return array
205 *              Données du pipeline complétées
206**/
207function motsar_formulaire_fond_avec_querypath($flux) {
208        if (!in_array($flux['args']['form'], array('editer_groupe_mot', 'editer_mot'))) {
209                return $flux;
210        }
211
212        $html = $flux['data'];
213        $env = $flux['args']['contexte'];
214
215        // charger QueryPath
216        include_spip('inc/querypath');
217        $qp = spip_query_path($html, 'body');
218
219
220        // sur le formulaire d'édition de mot
221        if ($flux['args']['form'] == 'editer_mot') {
222                // la parenté sur tous
223                // on récupère le sélecteur et on l'ajoute après le titre...
224                $selecteur_parent = recuperer_fond('formulaires/selecteur_mot_parent', $env);
225                $qp->top('body')->find('.editer_titre')->after($selecteur_parent);
226        }
227
228        // sur le formulaire d'édition de mot
229        elseif ($flux['args']['form'] == 'editer_groupe_mot') {
230                // l'option oui/non technique pour autoriser les mots_arborescents
231                $option_mots_arborescents = recuperer_fond('formulaires/option_mots_arborescents', $env);
232                $qp->top('body')->find('.fieldset_config')->append($option_mots_arborescents);
233        }
234
235        // retourner le HTML modifie
236        $flux['data'] = $qp->top('body>div')->xhtml();
237
238        return $flux;
239}
240
241
242/**
243 * Insère des modifications juste avant la création d'un mot
244 *
245 * Lors de la création d'un mot :
246 * - Ajoute l'id_mot_racine et l'id_parent
247 *
248 * Lors de la création d'un groupe de mot :
249 * - Ajoute l'option mots_arborescents
250 *
251 * @pipeline pre_insertion
252 * @param array $flux
253 *     Données du pipeline
254 * @return array
255 *     Données du pipeline complétées
256**/
257function motsar_pre_insertion($flux) {
258        // lors de la création d'un mot
259        if ($flux['args']['table'] == 'spip_mots') {
260                if ($id_parent = _request('id_parent')) {
261                        $id_racine = sql_getfetsel('id_mot_racine', 'spip_mots', 'id_mot=' . sql_quote($id_parent));
262                        // si et seulement si le parent demandé existe
263                        if ($id_racine) {
264                                $flux['data']['id_parent'] = $id_parent;
265                                $flux['data']['id_mot_racine'] = $id_racine;
266                        }
267                }
268        }
269        // lors de la création d'un groupe de mot
270        if ($flux['args']['table'] == 'spip_groupes_mots') {
271                if ($mots_arborescents = _request('mots_arborescents')) {
272                        $flux['data']['mots_arborescents'] = $mots_arborescents;
273                }
274        }
275        return $flux;
276}
277
278
279
280/**
281 * Insère des modifications juste après de la création d'un mot
282 *
283 * Lors de la création d'un mot :
284 * - Ajoute l'id_mot_racine si le mot est à la racine
285 *
286 * @pipeline post_insertion
287 * @param array $flux
288 *     Données du pipeline
289 * @return array
290 *     Données du pipeline complétées
291**/
292function motsar_post_insertion($flux) {
293        // lors de la création d'un groupe
294        if ($flux['args']['table'] == 'spip_mots') {
295                $id_mot = $flux['args']['id_objet'];
296                // si le mot est à la racine,
297                // c'est a dire que 'id_mot_racine' n'est pas défini ou nul
298                // c'est que nous avons créé un mot racine. Il faut mettre
299                // id_mot_racine sur id_mot, maintenant qu'on le connait.
300                if (empty($flux['data']['id_mot_racine'])) {
301                        sql_updateq('spip_mots', array('id_mot_racine' => $id_mot), 'id_mot=' . sql_quote($id_mot));
302                }
303        }
304        return $flux;
305}
306
307
308/**
309 * Insère des modifications lors de l'édition de mots
310 *
311 * Lors de l'édition d'un mot :
312 * - Modifie l'id_parent choisi et définit l'id_mot_racine et la profondeur
313 *
314 * Lors de l'édition d'un groupe de mot :
315 * - Prend en compte l'option mots_arborescents
316 *
317 * @pipeline pre_edition
318 * @param array $flux
319 *     Données du pipeline
320 * @return array
321 *     Données du pipeline complétées
322**/
323function motsar_pre_edition($flux) {
324        // lors de l'édition d'un mot
325        $table = 'spip_mots';
326        if ($flux['args']['table'] == $table
327        and $flux['args']['action'] == 'modifier')
328        {
329                $id_mot = $flux['args']['id_objet'];
330                $id_parent_ancien  = sql_getfetsel('id_parent', $table, 'id_mot=' . sql_quote($id_mot));
331                $id_parent_nouveau = _request('id_parent');
332                // uniquement s'ils sont différents
333                if ($id_parent_ancien != $id_parent_nouveau
334                // que le nouveau parent n'est pas notre groupe !
335                and $id_mot != $id_parent_nouveau
336                // et que le groupe parent n'est pas un de nos enfants
337                and include_spip('motsar_fonctions') // calcul_branche_mot_in
338                and !in_array($id_parent_nouveau, explode(',', calcul_branche_mot_in($id_mot)))
339                ) {
340                        $id_racine = '';
341                        $profondeur = 0;
342                        // soit c'est la racine
343                        if (!$id_parent_nouveau) {
344                                // auquel cas l'identifiant racine est le meme que notre mot, qui migre à la racine
345                                $id_racine = $id_mot;
346                        // soit le groupe existe
347                        } else {
348                                $parent = sql_fetsel(array('profondeur', 'id_mot_racine'), $table, 'id_mot=' . sql_quote($id_parent_nouveau));
349                                if ($parent) {
350                                        $id_racine  = $parent['id_mot_racine'];
351                                        $profondeur = $parent['profondeur'] + 1;
352                                }
353                        }
354                        if ($id_racine) {
355                                $flux['data']['id_parent']     = $id_parent_nouveau;
356                                $flux['data']['id_mot_racine'] = $id_racine;
357                                $flux['data']['profondeur']    = $profondeur;
358                                // pour le pipeline de post_edition. Permet entre autre de savoir
359                                // qu'il faudra actualiser les mots de la branche
360                                set_request('motsar_definir_heritages', true);
361                        }
362                }
363        }
364
365        // lors de l'édition d'un groupe de mot
366        if ($flux['args']['table'] == 'spip_groupes_mots'
367        and $flux['args']['action'] == 'modifier')
368        {
369                if ($mots_arborescents = _request('mots_arborescents')) {
370                        $mots_arborescents_ancien = sql_getfetsel('mots_arborescents', 'spip_groupes_mots', 'id_groupe=' . sql_quote($flux['args']['id_objet']));
371                        $flux['data']['mots_arborescents'] = $mots_arborescents;
372                        if ($mots_arborescents_ancien != $mots_arborescents) {
373                                // pour le pipeline de post_edition. Permet entre autre de savoir
374                                // qu'il faudra actualiser les mots de la branche
375                                set_request('motsar_definir_heritages', true);
376                        }
377                }
378        }
379        return $flux;
380}
381
382/**
383 * Modifie les données héritées d'un mot
384 *
385 * Modifie les héritages lorsqu'un parent change ou lorsqu'on modifie
386 * un mot racine qui a pu changer des données
387 *
388 * Modifie les mots si la configuration d'un groupe est modifiée : on les applatit.
389 *
390 * @pipeline post_edition
391 * @param array $flux
392 *     Données du pipeline
393 * @return array
394 *     Données du pipeline complétées
395**/
396function motsar_post_edition($flux) {
397        // lors de l'édition d'un mot
398        if ($flux['args']['table']  == 'spip_mots' and $flux['args']['action'] == 'modifier'
399                // soit le parent a change, soit le groupe racine est modifie
400                and (_request('motsar_definir_heritages') OR empty($flux['data']['id_parent'])))
401        {
402                $id_mot = $flux['args']['id_objet'];
403                include_spip('motsar_fonctions');
404                motsar_definir_heritages_mot($id_mot);
405                propager_les_mots_arborescents();
406        }
407
408        // lors de l'édition d'un groupe de mot
409        elseif ($flux['args']['table']  == 'spip_groupes_mots' and $flux['args']['action'] == 'modifier'
410                // si la configuration mots_arborescents a été modifiée
411                and _request('motsar_definir_heritages'))
412        {
413                $id_groupe = $flux['args']['id_objet'];
414                include_spip('motsar_fonctions');
415                motsar_definir_heritages($id_groupe);
416                propager_les_mots_arborescents();
417        }
418
419        return $flux;
420}
Note: See TracBrowser for help on using the repository browser.