source: spip-zone/_plugins_/champs_extras_core/trunk/cextras_pipelines.php @ 99134

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

Complément sur r99133 : je m'étais entourloupé avec l'option 'id_auteur' qui n'a pas à exister.
On ajoute plutôt un paramètre $id_objet, puisque c'est en fait ça que l'on attend peut être
pour tester les autorisations (et pas un identifiant d'auteur, je m'étais trompé car j'ai
repris un code que j'utilisais sur un formulaire de profil sur l'objet auteur).

Et sinon un moyen (pas spécialement chouette) d'avoir le comportement souhaité pour le formulaire
d'inscription de newsletter peut être d'appeler aussi le pipeline pre_insertion dessus, tel que :

`
function demo_formulaire_charger($flux) {

if ($fluxargs?form? == 'newsletter_subscribe') {

include_spip('inc/cextras');
if ($saisies = cextras_obtenir_saisies_champs_extras('mailsubscribers')) {

$flux_champs_extras_saisies? = $saisies;

}

}
return $flux;

}

function demo_pre_insertion($flux) {

if ($fluxargs?table? == 'spip_mailsubscribers') {

include_spip('cextras_pipelines');
$_flux = $flux;
$_fluxargs?id_objet? = null;
$_flux = cextras_pre_edition($_flux);
$fluxdata? = $_fluxdata?;

}
return $flux;

}
`

On exécute juste le pipeline de champs extra (mais il attend 'id_objet' en plus)

Voilà… SAD quand tu nous tiens.

File size: 12.9 KB
Line 
1<?php
2
3/**
4 * Utilisations de pipelines
5 *
6 * @package SPIP\Cextras\Pipelines
7**/
8
9// sécurité
10if (!defined("_ECRIRE_INC_VERSION")) return;
11
12/**
13 * Retourne la liste des saisies de champs extras concernant un objet donné
14 *
15 * @pipeline_appel declarer_champs_extras
16 * @param string $table
17 *     Nom d'une table SQL éditoriale
18 * @return array
19 *     Liste des saisies de champs extras de l'objet
20**/
21function champs_extras_objet($table) {
22        static $saisies_tables = array();
23        if (!$saisies_tables) {
24                $saisies_tables = pipeline('declarer_champs_extras', array());
25        }
26        return isset($saisies_tables[$table]) ? $saisies_tables[$table] : array();
27}
28
29/**
30 * Filtrer par autorisation les saisies transmises
31 *
32 * Chacune des saisies est parcourue et si le visiteur n'a pas l'autorisation
33 * de la voir, elle est enlevée de la liste.
34 * La fonction ne retourne donc que la liste des saisies que peut voir
35 * la personne.
36 *
37 * @param string $faire
38 *     Type d'autorisation testée : 'voir', 'modifier'
39 * @param string $quoi
40 *     Type d'objet tel que 'article'
41 * @param array $saisies
42 *     Liste des saisies à filtrer
43 * @param array $args
44 *     Arguments pouvant être utiles à l'autorisation
45 * @return array
46 *     Liste des saisies filtrées
47**/
48function champs_extras_autorisation($faire, $quoi='', $saisies=array(), $args=array()) {
49        if (!$saisies) return array();
50        include_spip('inc/autoriser');
51
52        foreach ($saisies as $cle=>$saisie) {
53                $id = isset($args['id']) ? $args['id'] : $args['id_objet'];
54                if (!autoriser($faire . 'extra', $quoi, $id, '', array(
55                        'type' => $quoi,
56                        'id_objet' => $id,
57                        'contexte' => isset($args['contexte']) ? $args['contexte'] : array(),
58                        'table' => table_objet_sql($quoi),
59                        'saisie' => $saisie,
60                        'champ' => $saisie['options']['nom'],
61                ))) {
62                        // on n'est pas autorise
63                        unset($saisies[$cle]);
64                }
65                else
66                {
67                        // on est autorise
68                        // on teste les sous-elements
69                        if (isset($saisie['saisies']) and $saisie['saisies']) {
70                                $saisies['saisies'] = champs_extras_autorisation($faire, $quoi, $saisie['saisies'], $args);
71                        }
72                }
73        }
74        return $saisies;
75}
76
77/**
78 * Ajoute pour chaque saisie de type SQL un drapeau (input hidden)
79 * permettant de retrouver les saisies editées.
80 *
81 * Particulièrement utile pour les checkbox qui ne renvoient
82 * rien si on les décoche.
83 *
84 * @param array $saisies
85 *     Liste de saisies
86 * @return array $saisies
87 *     Saisies complétées des drapeaux d'édition
88**/
89function champs_extras_ajouter_drapeau_edition($saisies) {
90        $saisies_sql = champs_extras_saisies_lister_avec_sql($saisies);
91        foreach ($saisies_sql as $saisie) {
92                $nom = $saisie['options']['nom'];
93                $saisies[] = array(
94                        'saisie' => 'hidden',
95                        'options' => array(
96                                'nom' => "cextra_$nom",
97                                'defaut' => 1 
98                        )
99                );
100        }
101        return $saisies;
102}
103
104// ---------- pipelines -----------
105
106
107/**
108 * Ajouter les champs extras sur les formulaires CVT editer_xx
109 *
110 * Liste les champs extras de l'objet, et s'il y en a les ajoute
111 * sur le formulaire d'édition en ayant filtré uniquement les saisies
112 * que peut voir le visiteur et en ayant ajouté des champs hidden
113 * servant à champs extras.
114 *
115 * @pipeline editer_contenu_objet
116 * @param array $flux Données du pipeline
117 * @return array      Données du pipeline
118**/ 
119function cextras_editer_contenu_objet($flux){
120        // recuperer les saisies de l'objet en cours
121        $objet = $flux['args']['type'];
122        include_spip('inc/cextras');
123        if ($saisies = champs_extras_objet( table_objet_sql($objet) )) {
124                // filtrer simplement les saisies que la personne en cours peut voir
125                $saisies = champs_extras_autorisation('modifier', $objet, $saisies, $flux['args']);
126                // pour chaque saisie presente, de type champs extras (hors fieldset et autres)
127                // ajouter un flag d'edition
128                $saisies = champs_extras_ajouter_drapeau_edition($saisies);
129                // ajouter au formulaire
130                $ajout = recuperer_fond('inclure/generer_saisies', array_merge($flux['args']['contexte'], array('saisies'=>$saisies)));
131
132                // div par défaut en 3.1+, mais avant ul / li
133                $balise = saisie_balise_structure_formulaire('ul');
134                $flux['data'] = preg_replace(
135                        '%(<!--extra-->)%is',
136                        "<$balise class='editer-groupe champs_extras'>$ajout</$balise>\n" . '$1',
137                        $flux['data']
138                );
139        }
140
141        return $flux;
142}
143
144
145/**
146 * Ajouter les champs extras soumis par les formulaire CVT editer_xx
147 *
148 * Pour chaque champs extras envoyé par le formulaire d'édition,
149 * ajoute les valeurs dans l'enregistrement à effectuer.
150 *
151 * @pipeline pre_edition
152 * @param array $flux Données du pipeline
153 * @return array      Données du pipeline
154**/ 
155function cextras_pre_edition($flux){
156
157        include_spip('inc/cextras');
158        include_spip('inc/saisies_lister');
159        $table = $flux['args']['table'];
160        if ($saisies = champs_extras_objet( $table )) {
161                // Restreindre les champs postés en fonction des autorisations de les modifier
162                // au cas où un malin voudrait en envoyer plus que le formulaire ne demande
163                $saisies = champs_extras_autorisation('modifier', objet_type($table), $saisies, $flux['args']);
164                $saisies = champs_extras_saisies_lister_avec_sql($saisies);
165                foreach ($saisies as $saisie) {
166                        $nom = $saisie['options']['nom'];
167                        if (_request('cextra_' .  $nom)) {
168                                $extra = _request($nom);
169                                if (is_array($extra)) {
170                                        $extra = join(',' , $extra);
171                                }
172                                $flux['data'][$nom] = corriger_caracteres($extra);
173                        }
174                }
175        }
176
177        return $flux;
178}
179
180
181/**
182 * Ajouter les champs extras sur la visualisation de l'objet
183 *
184 * S'il y a des champs extras sur l'objet, la fonction les ajoute
185 * à la vue de l'objet, en enlevant les saisies que la personne n'a
186 * pas l'autorisation de voir.
187 *
188 * @pipeline afficher_contenu_objet
189 * @param array $flux Données du pipeline
190 * @return array      Données du pipeline
191**/ 
192function cextras_afficher_contenu_objet($flux){
193        // recuperer les saisies de l'objet en cours
194        $objet = $flux['args']['type'];
195        include_spip('inc/cextras');
196        if ($saisies = champs_extras_objet( $table = table_objet_sql($objet) )) {
197                // ajouter au contexte les noms et valeurs des champs extras
198                $saisies_sql = champs_extras_saisies_lister_avec_sql($saisies);
199                $valeurs = sql_fetsel(array_keys($saisies_sql), $table, id_table_objet($table) . '=' . sql_quote($flux['args']['id_objet']));
200                if (!$valeurs) {
201                        $valeurs = array();
202                } else {
203                        // on applique les eventuels traitements definis
204                        // /!\ La saisies-vues/_base applique |propre par defaut si elle ne trouve pas de saisie
205                        // Dans ce cas, certains traitements peuvent être effectués 2 fois !
206                        $saisies_traitees = saisies_lister_avec_traitements($saisies_sql);
207                        unset($saisies_sql);
208
209                        // Fournir $connect et $Pile[0] au traitement si besoin (l'evil eval)
210                        $connect = '';
211                        $Pile = array(0 => (isset($flux['args']['contexte']) ? $flux['args']['contexte'] : array()));
212
213                        foreach ($saisies_traitees as $saisie) {
214                                $traitement = $saisie['options']['traitements'];
215                                $traitement = defined($traitement) ? constant($traitement) : $traitement;
216                                $nom = $saisie['options']['nom'];
217                                list($avant, $apres) = explode('%s', $traitement);
218                                eval('$val = ' . $avant . ' $valeurs[$nom] ' . $apres . ';');
219                                $valeurs[$nom] = $val;
220                        }
221                }
222
223                $contexte = isset($flux['args']['contexte']) ? $flux['args']['contexte'] : array();
224                $contexte = array_merge($contexte, $valeurs);
225
226                // restreindre la vue selon les autorisations
227                $saisies = champs_extras_autorisation('voir', $objet, $saisies, $flux['args']);
228
229                // ajouter les vues
230                $flux['data'] .= recuperer_fond('inclure/voir_saisies', array_merge($contexte, array(
231                                        'saisies' => $saisies,
232                                        'valeurs' => $valeurs,
233                )));
234        }
235
236        return $flux;
237}
238
239/**
240 * Vérification de la validité des champs extras
241 *
242 * Lorsqu'un formulaire 'editer_xx' se présente, la fonction effectue,
243 * pour chaque champs extra les vérifications prévues dans la
244 * définition de la saisie, et retourne les éventuelles erreurs rencontrées.
245 *
246 * @pipeline formulaire_verifier
247 * @param array $flux Données du pipeline
248 * @return array      Données du pipeline
249**/ 
250function cextras_formulaire_verifier($flux){
251        $form = $flux['args']['form'];
252       
253        if (strncmp($form, 'editer_', 7) !== 0) {
254                return $flux;
255        }
256       
257        $objet = substr($form, 7);
258        if ($saisies = champs_extras_objet( $table = table_objet_sql($objet) )) {
259                include_spip('inc/autoriser');
260                include_spip('inc/saisies');
261
262                // restreindre les saisies selon les autorisations
263                $id_objet = $flux['args']['args'][0]; // ? vraiment toujours ?
264                $saisies = champs_extras_autorisation('modifier', $objet, $saisies, array_merge($flux['args'], array(
265                        'id' => $id_objet,
266                        'contexte' => array()))); // nous ne connaissons pas le contexte dans ce pipeline
267
268                // restreindre les vérifications aux saisies enregistrables
269                $saisies = champs_extras_saisies_lister_avec_sql($saisies);
270
271                $verifier = charger_fonction('verifier', 'inc', true);
272
273                foreach ($saisies as $saisie) {
274                        // verifier obligatoire
275                        $nom = $saisie['options']['nom'];
276                        if (isset($saisie['options']['obligatoire']) and $saisie['options']['obligatoire']
277                        and !_request($nom))
278                        {
279                                $flux['data'][$nom] = _T('info_obligatoire');
280                       
281                        // verifier (api) + normalisation
282                        } elseif ($verifier
283                           AND isset($saisie['verifier']['type'])
284                           AND $verif = $saisie['verifier']['type'])
285                        {
286                                $options = isset($saisie['verifier']['options']) ? $saisie['verifier']['options'] : array();
287                                $normaliser = null;
288                                $valeur = _request($nom);
289                                if ($erreur = $verifier($valeur, $verif, $options, $normaliser)) {
290                                        $flux['data'][$nom] = $erreur;
291                                // si une valeur de normalisation a ete transmis, la prendre.
292                                } elseif (!is_null($normaliser)) {
293                                        set_request($nom, $normaliser);
294                                } else {
295
296                                        // [FIXME] exceptions connues de vérifications (pour les dates entre autres)
297                                        // en attendant une meilleure solution !
298                                        //
299                                        // Lorsque le champ n'est pas rempli dans le formulaire
300                                        // alors qu'une normalisation est demandée,
301                                        // verifier() sort sans indiquer d'erreur (c'est normal).
302                                        //
303                                        // Sauf que la donnée alors soumise à SQL sera une chaine vide,
304                                        // ce qui ne correspond pas toujours à ce qui est attendu.
305                                        if ((is_string($valeur) and !strlen($valeur) or (is_array($valeur) and $saisie['saisie']=='date'))
306                                          and isset($options['normaliser'])
307                                          and $norme = $options['normaliser']) {
308                                                // Charger la fonction de normalisation théoriquement dans verifier/date
309                                                // et si on en trouve une, obtenir la valeur normalisée
310                                                // qui est théoriquement la valeur par défaut, puisque $valeur est vide
311                                                include_spip("verifier/$verif");
312                                                if ($normaliser = charger_fonction("${verif}_${norme}", "normaliser", true)) {
313                                                        $erreur = null;
314                                                        $defaut = $normaliser($valeur, $options, $erreur);
315                                                        if (is_null($erreur)) {
316                                                                set_request($nom, $defaut);
317                                                        } else {
318                                                                // on affecte l'erreur, mais il est probable que
319                                                                // l'utilisateur ne comprenne pas grand chose
320                                                                $flux['data'][$nom] = $erreur;
321                                                        }
322                                                } else {
323                                                        include_spip('inc/cextras');
324                                                        extras_log("Fonction de normalisation pour ${verif}_${norme} introuvable");
325                                                }
326
327                                        }
328                                }
329                        }
330                }
331        }
332        return $flux;
333}
334
335/**
336 * Insertion dans le pipeline revisions_chercher_label (Plugin révisions)
337 * Trouver le bon label à afficher sur les champs dans les listes de révisions
338 *
339 * Si un champ est un champ extra, son label correspond au label défini du champs extra
340 *
341 * @pipeline revisions_chercher_label
342 * @param array $flux Données du pipeline
343 * @return array      Données du pipeline
344**/ 
345function cextras_revisions_chercher_label($flux) {
346        $table = table_objet_sql($flux['args']['objet']);
347        $saisies_tables = champs_extras_objet($table);
348        foreach($saisies_tables as $champ){
349                if($champ['options']['nom'] == $flux['args']['champ']){
350                        $flux['data'] = $champ['options']['label'];
351                        break;
352                }
353        }
354        return $flux;
355}
356
357
358/**
359 * Ajouter les saisies de champs extras sur des formulaires spécifiques
360 *
361 * Les champs extras s'ajoutent déjà automatiquement sur les formulaires d'édition
362 * des objets éditoriaux. Pour d'autres formulaires plus spécifiques, tel
363 * que des formulaires d'inscriptions, il est possible d'envoyer,
364 * dans la partie 'charger' du formulaire en question la clé
365 * `_champs_extras_saisies`, listant les saisies à afficher dedans.
366 *
367 * Elles seront ajoutées automatiquement à l'endroit où le code
368 * html `<!--extra-->` est présent dans le formulaire.
369 *
370 * @see cextras_obtenir_saisies_champs_extras() qui aide à récupérer les saisies.
371 *
372 * @param array $flux
373 * @return array
374**/
375function cextras_formulaire_fond($flux) {
376        if (!empty($flux['args']['contexte']['_champs_extras_saisies'])) {
377                $saisies = $flux['args']['contexte']['_champs_extras_saisies'];
378
379                // ajouter au formulaire
380                $ajout = recuperer_fond('inclure/generer_saisies', array_merge($flux['args']['contexte'], array('saisies' => $saisies)));
381
382                // div par défaut en 3.1+, mais avant ul / li
383                $balise = saisie_balise_structure_formulaire('ul');
384                $flux['data'] = preg_replace(
385                        '%(<!--extra-->)%is',
386                        "<$balise class='editer-groupe champs_extras'>$ajout</$balise>\n" . '$1',
387                        $flux['data']
388                );
389        }
390        return $flux;
391}
Note: See TracBrowser for help on using the repository browser.