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

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

Plugin (en construction) pour permettre d'avoir des mots arborescents.

Ajoute une option sur les groupes de mots, permettant d'activer, pour un groupe, des arborescentes de mots.
Ajoute sur la table des mots des champs nécessaires pour gérer l'arborescence (id_parent, id_mot_racine, profondeur)

Surcharge certains fichiers (particulièrement dans prive/objets/liste/) du plugin mots, comme le fait également le plugin
«Groupes de mots arborescents». De la sorte, en l'état actuel, les 2 plugins sont incompatibles (même si il me semble
que leurs actions respectives peuvent fonctionner ensemble ; c'est surtout un problème d'affichage / de surcharge des mêmes fichiers).

Pour l'instant le plugin permet de créer des mots arborescents et de les lister, pour les groupes le permettant.

Il reste à faire : les squelettes d'association de mots, quelques restrictions sur l'édition d'un mot,
tel que ne pas permettre de modifier en même temps ET le groupe de mot parent, et le mot parent.

File size: 12.0 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 que le parent d'un mot
97 * n'est pas ce mot lui-même !
98 *
99 * @pipeline formulaire_verifier
100 * @param array $flux
101 *              Données du pipeline
102 * @return array
103 *              Données du pipeline complétées
104**/
105function motsar_formulaire_verifier($flux) {
106        // sur le formulaire d'édition de groupe de mot
107        if ($flux['args']['form'] == 'editer_mot') {
108                // tester que le parent ne vaut pas le groupe
109                if ($id_parent = _request('id_parent')
110                and $id_mot = _request('id_mot'))
111                {
112                        if ($id_parent == $id_mot) {
113                                $flux['data']['id_parent'] = _T('motsar:erreur_parent_sur_mot');
114                        }
115                        elseif (
116                          include_spip('motsar_fonctions') // calcul_branche_mot_in
117                          and in_array($id_parent, explode(',', calcul_branche_mot_in($id_mot))))
118                        {
119                                $flux['data']['id_parent'] = _T('motsar:erreur_parent_sur_mot_enfant');
120                        }
121                }
122        }
123        return $flux;
124}
125
126
127
128
129/**
130 * Modifie les champs du formulaire de groupe de mot et de mots
131 *
132 * Sur les mots :
133 * - ajouter le sélecteur de parenté
134 *
135 * Sur les groupes :
136 * - proposer l'option mots_arborescents
137 *
138 * @pipeline formulaire_fond
139 * @param array $flux
140 *              Données du pipeline
141 * @return array
142 *              Données du pipeline complétées
143**/
144function motsar_formulaire_fond($flux) {
145        if (!in_array($flux['args']['form'], array('editer_groupe_mot', 'editer_mot'))) {
146                return $flux;
147        }
148
149        $env = $flux['args']['contexte'];
150
151        // sur le formulaire d'édition de mot
152        if ($flux['args']['form'] == 'editer_mot') {
153                // la parenté sur tous : on récupère le sélecteur et on l'ajoute après le titre...
154                $selecteur_parent = recuperer_fond('formulaires/selecteur_mot_parent', $env);
155
156                $cherche = "/(<(li|div)[^>]*class=(?:'|\")editer editer_titre.*?<\/\\2>)\s*(<(li|div)[^>]*class=(?:'|\")editer)/is";
157                if (preg_match($cherche, $flux['data'], $m)) {
158                        $flux['data'] = preg_replace($cherche, '$1'.$selecteur_parent.'$3', $flux['data'], 1);
159                }
160        }
161
162        // sur le formulaire d'édition de mot
163        elseif ($flux['args']['form'] == 'editer_groupe_mot') {
164                // l'option oui/non technique pour autoriser les mots_arborescents
165                $option_mots_arborescents = recuperer_fond('formulaires/option_mots_arborescents', $env);
166
167                $cherche = "/(<(li|div)[^>]*class=(?:'|\")editer editer_groupe_mots_reglage_avance.*?<\/\\2>)\s*(<(li|div)[^>]*class=(?:'|\")editer)/is";
168                if (preg_match($cherche, $flux['data'], $m)) {
169                        $flux['data'] = preg_replace($cherche, '$1'.$option_mots_arborescents.'$3', $flux['data'], 1);
170                }
171        }
172
173        return $flux;
174}
175
176/**
177 * Modifie les champs du formulaire de groupe de mot et de mots
178 *
179 * Sur les mots :
180 * - ajouter le sélecteur de parenté
181 *
182 * Sur les groupes :
183 * - proposer l'option mots_arborescents
184 *
185 * @pipeline formulaire_fond
186 * @note
187 *     Code utilisant querypath (mais non fonctionnel avec libxml version 2.9.2 :/)
188 *
189 * @param array $flux
190 *              Données du pipeline
191 * @return array
192 *              Données du pipeline complétées
193**/
194function motsar_formulaire_fond_avec_querypath($flux) {
195        if (!in_array($flux['args']['form'], array('editer_groupe_mot', 'editer_mot'))) {
196                return $flux;
197        }
198
199        $html = $flux['data'];
200        $env = $flux['args']['contexte'];
201
202        // charger QueryPath
203        include_spip('inc/querypath');
204        $qp = spip_query_path($html, 'body');
205
206
207        // sur le formulaire d'édition de mot
208        if ($flux['args']['form'] == 'editer_mot') {
209                // la parenté sur tous
210                // on récupère le sélecteur et on l'ajoute après le titre...
211                $selecteur_parent = recuperer_fond('formulaires/selecteur_mot_parent', $env);
212                $qp->top('body')->find('.editer_titre')->after($selecteur_parent);
213        }
214
215        // sur le formulaire d'édition de mot
216        elseif ($flux['args']['form'] == 'editer_groupe_mot') {
217                // l'option oui/non technique pour autoriser les mots_arborescents
218                $option_mots_arborescents = recuperer_fond('formulaires/option_mots_arborescents', $env);
219                $qp->top('body')->find('.fieldset_config')->append($option_mots_arborescents);
220        }
221
222        // retourner le HTML modifie
223        $flux['data'] = $qp->top('body>div')->xhtml();
224
225        return $flux;
226}
227
228
229/**
230 * Insère des modifications juste avant la création d'un mot
231 *
232 * Lors de la création d'un mot :
233 * - Ajoute l'id_mot_racine et l'id_parent
234 *
235 * Lors de la création d'un groupe de mot :
236 * - Ajoute l'option mots_arborescents
237 *
238 * @pipeline pre_insertion
239 * @param array $flux
240 *     Données du pipeline
241 * @return array
242 *     Données du pipeline complétées
243**/
244function motsar_pre_insertion($flux) {
245        // lors de la création d'un mot
246        if ($flux['args']['table'] == 'spip_mots') {
247                if ($id_parent = _request('id_parent')) {
248                        $id_racine = sql_getfetsel('id_mot_racine', 'spip_mots', 'id_mot=' . sql_quote($id_parent));
249                        // si et seulement si le parent demandé existe
250                        if ($id_racine) {
251                                $flux['data']['id_parent'] = $id_parent;
252                                $flux['data']['id_mot_racine'] = $id_racine;
253                        }
254                }
255        }
256        // lors de la création d'un groupe de mot
257        if ($flux['args']['table'] == 'spip_groupes_mots') {
258                if ($mots_arborescents = _request('mots_arborescents')) {
259                        $flux['data']['mots_arborescents'] = $mots_arborescents;
260                }
261        }
262        return $flux;
263}
264
265
266
267/**
268 * Insère des modifications juste après de la création d'un mot
269 *
270 * Lors de la création d'un mot :
271 * - Ajoute l'id_mot_racine si le mot est à la racine
272 *
273 * @pipeline post_insertion
274 * @param array $flux
275 *     Données du pipeline
276 * @return array
277 *     Données du pipeline complétées
278**/
279function motsar_post_insertion($flux) {
280        // lors de la création d'un groupe
281        if ($flux['args']['table'] == 'spip_mots') {
282                $id_mot = $flux['args']['id_objet'];
283                // si le mot est à la racine,
284                // c'est a dire que 'id_mot_racine' n'est pas défini ou nul
285                // c'est que nous avons créé un mot racine. Il faut mettre
286                // id_mot_racine sur id_mot, maintenant qu'on le connait.
287                if (empty($flux['data']['id_mot_racine'])) {
288                        sql_updateq('spip_mots', array('id_mot_racine' => $id_mot), 'id_mot=' . sql_quote($id_mot));
289                }
290        }
291        return $flux;
292}
293
294
295/**
296 * Insère des modifications lors de l'édition de mots
297 *
298 * Lors de l'édition d'un mot :
299 * - Modifie l'id_parent choisi et définit l'id_mot_racine et la profondeur
300 *
301 * Lors de l'édition d'un groupe de mot :
302 * - Prend en compte l'option mots_arborescents
303 *
304 * @pipeline pre_edition
305 * @param array $flux
306 *     Données du pipeline
307 * @return array
308 *     Données du pipeline complétées
309**/
310function motsar_pre_edition($flux) {
311        // lors de l'édition d'un mot
312        $table = 'spip_mots';
313        if ($flux['args']['table'] == $table
314        and $flux['args']['action'] == 'modifier')
315        {
316                $id_mot = $flux['args']['id_objet'];
317                $id_parent_ancien  = sql_getfetsel('id_parent', $table, 'id_mot=' . sql_quote($id_mot));
318                $id_parent_nouveau = _request('id_parent');
319                // uniquement s'ils sont différents
320                if ($id_parent_ancien != $id_parent_nouveau
321                // que le nouveau parent n'est pas notre groupe !
322                and $id_mot != $id_parent_nouveau
323                // et que le groupe parent n'est pas un de nos enfants
324                and include_spip('motsar_fonctions') // calcul_branche_mot_in
325                and !in_array($id_parent_nouveau, explode(',', calcul_branche_mot_in($id_mot)))
326                ) {
327                        $id_racine = '';
328                        $profondeur = 0;
329                        // soit c'est la racine
330                        if (!$id_parent_nouveau) {
331                                // auquel cas l'identifiant racine est le meme que notre mot, qui migre à la racine
332                                $id_racine = $id_mot;
333                        // soit le groupe existe
334                        } else {
335                                $parent = sql_fetsel(array('profondeur', 'id_mot_racine'), $table, 'id_mot=' . sql_quote($id_parent_nouveau));
336                                if ($parent) {
337                                        $id_racine  = $parent['id_mot_racine'];
338                                        $profondeur = $parent['profondeur'] + 1;
339                                }
340                        }
341                        if ($id_racine) {
342                                $flux['data']['id_parent']     = $id_parent_nouveau;
343                                $flux['data']['id_mot_racine'] = $id_racine;
344                                $flux['data']['profondeur']    = $profondeur;
345                                // pour le pipeline de post_edition. Permet entre autre de savoir
346                                // qu'il faudra actualiser les mots de la branche
347                                set_request('motsar_definir_heritages', true);
348                        }
349                }
350        }
351
352        // lors de l'édition d'un groupe de mot
353        if ($flux['args']['table'] == 'spip_groupes_mots'
354        and $flux['args']['action'] == 'modifier')
355        {
356                if ($mots_arborescents = _request('mots_arborescents')) {
357                        $flux['data']['mots_arborescents'] = $mots_arborescents;
358                }
359        }
360        return $flux;
361}
362
363/**
364 * Modifie les données héritées d'un mot
365 *
366 * Modifie les héritages lorsqu'un parent change ou lorsqu'on modifie
367 * un mot racine qui a pu changer des données
368 *
369 * Modifie les mots si la configuration d'un groupe est modifiée : on les applatit.
370 *
371 * @pipeline post_edition
372 * @param array $flux
373 *     Données du pipeline
374 * @return array
375 *     Données du pipeline complétées
376**/
377function motsar_post_edition($flux) {
378        // lors de l'édition d'un mot
379        if ($flux['args']['table']  == 'spip_mots' and $flux['args']['action'] == 'modifier'
380                // soit le parent a change, soit le groupe racine est modifie
381                and (_request('motsar_definir_heritages') OR empty($flux['data']['id_parent'])))
382        {
383                $id_mot = $flux['args']['id_objet'];
384                include_spip('motsar_fonctions');
385                motsar_definir_heritages_mot($id_mot);
386                propager_les_mots_arborescents();
387        }
388
389        // lors de l'édition d'un groupe de mot
390        elseif ($flux['args']['table']  == 'spip_groupes_mots' and $flux['args']['action'] == 'modifier'
391                // soit le parent a change, soit le groupe racine est modifie
392                and ($mots_arborescents = _request('mots_arborescents')))
393        {
394                $id_groupe = $flux['args']['id_objet'];
395                include_spip('motsar_fonctions');
396                motsar_definir_heritages($id_groupe);
397        }
398
399        return $flux;
400}
Note: See TracBrowser for help on using the repository browser.