source: spip-zone/_plugins_/albums/trunk/albums_pipelines.php

Last change on this file was 111845, checked in by tcharlss@…, 8 months ago

Revert des trucs commités en trop avec r111843

File size: 24.3 KB
Line 
1<?php
2/**
3 * Utilisations de pipelines par le plugin Albums
4 *
5 * @plugin     Albums
6 * @copyright  2014
7 * @author     Tetue, Charles Razack
8 * @licence    GNU/GPL
9 * @package    SPIP\Albums\Pipelines
10 */
11
12// Sécurité
13if (!defined('_ECRIRE_INC_VERSION')) {
14        return;
15}
16
17
18/**
19 * Ajout de contenu aux fiches des objets.
20 *
21 * - Albums liés aux objets activés dans la configuration du plugin
22 * - Documents liés aux albums en cas d'absence du portfolio (cf. note)
23 *
24 * @note
25 * Les portfolios ne sont affichés que pour les objets qu'on a le droit d'éditer
26 * (cf. `autoriser_joindredocument_dist`).
27 * Mais pour les albums, les documents doivent être visibles dans tous les cas.
28 * Si nécessaire, on affiche donc les documents via notre squelette maison.
29 *
30 * @uses marquer_doublons_album()
31 * @pipeline afficher_complement_objet
32 *
33 * @param  array $flux Données du pipeline
34 * @return array       Données du pipeline
35 */
36function albums_afficher_complement_objet($flux) {
37
38        $texte = '';
39        $e     = trouver_objet_exec($flux['args']['type']);
40        $id    = intval($flux['args']['id']);
41
42        // Fiches des objets activés : albums liés
43        if (
44                $e !== false // page d'un objet éditorial
45                and $e['edition'] === false // pas en mode édition
46                and $type = $e['type']
47                and autoriser('ajouteralbum', $type, $id)
48        ) {
49                // on vérifie d'abord que les albums vus sont bien liés
50                $table_objet_sql = table_objet_sql($type);
51                $table_objet     = table_objet($type);
52                $id_table_objet  = id_table_objet($type);
53                $champs          = sql_fetsel('*', $table_objet_sql, addslashes($id_table_objet).'='.intval($id));
54                $marquer_doublons_album = charger_fonction('marquer_doublons_album', 'inc');
55                $marquer_doublons_album($champs, $id, $type, $id_table_objet, $table_objet, $table_objet_sql);
56                // puis on récupère le squelette
57                $texte .= recuperer_fond('prive/squelettes/contenu/portfolio_albums', array(
58                                'objet' => $type,
59                                'id_objet' => $id,
60                        ), array('ajax'=>'albums'));
61        }
62
63        // Fiches des albums : documents liés quand les documents «classiques» ne sont pas affichés
64        if (
65                $e !== false // page d'un objet éditorial
66                and $e['edition'] === false // pas en mode édition
67                and ($type=$e['type']) == 'album'
68                and !autoriser('joindredocument', $type, $id)
69        ) {
70                $texte .= recuperer_fond(
71                        'prive/squelettes/inclure/documents_album',
72                        array('id_album' => $id, 'pagination_documents'=>30)
73                );
74        }
75
76        if ($texte) {
77                if ($p = strpos($flux['data'], '<!--afficher_complement_objet-->')) {
78                        $flux['data'] = substr_replace($flux['data'], $texte, $p, 0);
79                } else {
80                        $flux['data'] .= $texte;
81                }
82        }
83
84        return $flux;
85}
86
87
88/**
89 * Ajout de contenu sur certaines pages.
90 *
91 * - Auteurs sur la fiche d'un album
92 * - Message sur la fiche d'un album si auteur pas autorisé à modifier (cf. autorisation)
93 *
94 * @pipeline affiche_milieu
95 *
96 * @param  array $flux Données du pipeline
97 * @return array       Données du pipeline
98 */
99function albums_affiche_milieu($flux) {
100
101        $texte = '';
102        $e     = trouver_objet_exec($flux['args']['exec']);
103
104        // Fiches des albums
105        if (
106                $e !== false // page d'un objet éditorial
107                and $e['edition'] === false // pas en mode édition
108                and $e['type'] == 'album'
109                and $id_objet=$flux['args'][$e['id_table_objet']]
110        ) {
111                // liste des auteurs liés
112                $texte .= recuperer_fond('prive/objets/editer/liens', array(
113                        'table_source' => 'auteurs',
114                        'objet' => 'album',
115                        'id_objet' => $id_objet
116                ));
117                // message si l'auteur de l'album n'est pas autorisé à le modifier
118                // c'est que l'album est lié à un objet qu'il ne peut pas modifier
119                include_spip('action/editer_liens');
120                $auteurs_album = array();
121                if (is_array($liens_auteurs = objet_trouver_liens(array('auteur' => '*'), array('album'=>$id_objet)))) {
122                        foreach ($liens_auteurs as $l) {
123                                $auteurs_album[] = $l['id_auteur'];
124                        }
125                }
126                $id_auteur = $GLOBALS['visiteur_session']['id_auteur'];
127                if (in_array($id_auteur, $auteurs_album) and !autoriser(modifier, album, $id_objet)) {
128                        $texte .= recuperer_fond('prive/squelettes/inclure/message_album_non_editable');
129                }
130        }
131
132        if ($texte) {
133                if ($p = strpos($flux['data'], '<!--affiche_milieu-->')) {
134                        $flux['data'] = substr_replace($flux['data'], $texte, $p, 0);
135                } else {
136                        $flux['data'] .= $texte;
137                }
138        }
139
140        return $flux;
141}
142
143
144/**
145 * Modifier ou ajouter du contenu dans la colonne de gauche.
146 *
147 * - Gestion des albums sur le formulaire d'édition d'un objet
148 * lorsqu'on peut lui ajouter des albums mais que l'ajout de documents est désactivé.
149 *
150 * @note
151 * Lors d'une première création de l'objet, celui-ci n'ayant pas
152 * encore d'identifiant tant que le formulaire d'edition n'est pas enregistré,
153 * les liaisions entre les albums liés et l'objet à créer sauvegardent
154 * un identifiant d'objet négatif de la valeur de id_auteur (l'auteur
155 * connecté). Ces liaisons seront corrigées apres validation dans albums_post_insertion()
156 * cf. plugin Médias.
157 *
158 * @pipeline affiche_gauche
159 *
160 * @param  array $flux Données du pipeline
161 * @return array       Données du pipeline
162 */
163function albums_affiche_gauche($flux) {
164
165        $texte = '';
166        $e = trouver_objet_exec($flux['args']['exec']);
167
168        // Edition des objets activés : gestion des albums
169        if (
170                $e !== false // page d'un objet éditorial
171                and $e['edition'] !== false // mode édition uniquement
172                and $type = $e['type']
173                and $id_table_objet = $e['id_table_objet']
174                and (
175                        (isset($flux['args'][$id_table_objet]) and $id = intval($flux['args'][$id_table_objet]))
176                        // id non défini pour les nouveaux objets : on met un identifiant negatif
177                        or ($id = 0-$GLOBALS['visiteur_session']['id_auteur'])
178                )
179                and autoriser('ajouteralbum', $type, $id)
180                and !autoriser('joindredocument', $type, $id)
181        ) {
182                $texte .= recuperer_fond(
183                        'prive/objets/editer/colonne_document',
184                        array('objet'=>$type,'id_objet'=>$id)
185                );
186        }
187
188        if ($texte) {
189                $flux['data'] .= $texte;
190        }
191
192        return $flux;
193}
194
195
196/**
197 * Actions effectuées après l'insertion d'un nouvel objet en base.
198 *
199 * - Mise à jour les liens temporaires avec les albums.
200 *
201 * @note
202 * Lors d'une première création de l'objet, celui-ci n'ayant pas
203 * encore d'identifiant tant que le formulaire d'edition n'est pas enregistré,
204 * les liaisions entre les albums liés et l'objet à créer sauvegardent
205 * un identifiant d'objet négatif de la valeur de id_auteur (l'auteur
206 * connecté).
207 * Une fois l'objet inséré en base, il faut rétablir ces liaisons
208 * avec le vrai identifiant de l'objet.
209 * cf. plugin Médias.
210 *
211 * @pipeline post_insertion
212 *
213 * @param  array $flux Données du pipeline
214 * @return array       Données du pipeline
215**/
216function albums_post_insertion($flux) {
217
218        $objet    = objet_type($flux['args']['table']);
219        $id_objet = $flux['args']['id_objet'];
220        include_spip('inc/autoriser');
221
222        if (
223                autoriser('ajouteralbum', $objet, $id_objet)
224                and $id_auteur = intval($GLOBALS['visiteur_session']['id_auteur'])
225        ) {
226                $id_temporaire = 0-$id_auteur;
227                include_spip('action/editer_liens');
228                $liens = objet_trouver_liens(array('album'=>'*'), array($objet=>$id_temporaire));
229                foreach ($liens as $lien) {
230                        objet_associer(array('album'=>$lien['id_album']), array($objet=>$id_objet));
231                }
232                // un simple delete pour supprimer les liens temporaires
233                sql_delete('spip_albums_liens', array('id_objet='.$id_temporaire, 'objet='.sql_quote($objet)));
234        }
235
236        return $flux;
237}
238
239
240/**
241 * Actions effectuées après l'édition d'un objet.
242 *
243 * - Mise à jour des liens avec les albums.
244 *
245 * @note
246 * cf. pipeline du plugin Médias
247 *
248 * @uses marquer_doublons_album()
249 * @pipeline post_edition
250 *
251 * @param  array $flux Données du pipeline
252 * @return array       Données du pipeline
253 */
254function albums_post_edition($flux) {
255
256        // si on édite un objet, mettre ses albums liés à jour
257        if (isset($flux['args']['table']) and $flux['args']['table'] != 'spip_albums') {
258                $table_objet_sql = $flux['args']['table'];
259                $serveur         = (isset($flux['args']['serveur']) ? $flux['args']['serveur'] : '');
260                $type            = isset($flux['args']['type']) ? $flux['args']['type'] : objet_type($table_objet_sql);
261                $id_objet        = $flux['args']['id_objet'];
262                $id_table_objet  = id_table_objet($type, $serveur);
263                $table_objet     = isset($flux['args']['table_objet']) ?
264                        $flux['args']['table_objet'] : table_objet($table_objet_sql, $serveur);
265
266                include_spip('inc/autoriser');
267                if (autoriser('autoassocieralbum', $type, $id_objet)) {
268                        $marquer_doublons_album = charger_fonction('marquer_doublons_album', 'inc');
269                        $marquer_doublons_album($flux['data'], $id_objet, $type, $id_table_objet, $table_objet, $table_objet_sql, '', $serveur);
270                }
271        }
272
273        return $flux;
274}
275
276
277/**
278 * Plugins Jquery UI nécessaires au plugin
279 *
280 * @pipeline jqueryui_plugins
281 *
282 * @param  array $scripts Liste des js chargés
283 * @return array          Liste complétée des js chargés
284**/
285function albums_jqueryui_plugins($plugins) {
286        if (test_espace_prive()) {
287                include_spip('inc/config');
288                $plugins[] = 'jquery.ui.autocomplete';
289                if (lire_config('albums/deplacer_documents')) {
290                        $plugins[] = 'jquery.ui.sortable';
291                }
292        }
293        return $plugins;
294}
295
296
297/**
298 * Ajout de feuilles de style CSS sur les pages publiques
299 *
300 * @pipeline insert_head_css
301 *
302 * @param string $flux Feuilles de styles
303 * @return string      Description complétée des feuilles de styles
304 */
305function albums_insert_head_css($flux) {
306
307        if (!defined('_ALBUMS_INSERT_HEAD_CSS') or !_ALBUMS_INSERT_HEAD_CSS) {
308                include_spip('inc/config');
309                if (!function_exists('liste_plugin_actifs')) {
310                        include_spip('inc/plugin');
311                }
312                $cfg = (defined('_ALBUMS_INSERT_HEAD_CSS') ? _ALBUMS_INSERT_HEAD_CSS : lire_config('albums/insert_head_css', 1));
313                if ($cfg) {
314                        // feuille de style minimale de base
315                        $flux .= '<link rel="stylesheet" href="'.direction_css(find_in_path('css/albums.css')).'" type="text/css" />';
316                }
317        }
318
319        return $flux;
320}
321
322
323/**
324 * Compter les albums liés à un objet
325 *
326 * @pipeline objet_compte_enfants
327 *
328 * @param  array $flux Données du pipeline
329 * @return array       Données du pipeline
330 */
331function albums_objet_compte_enfants($flux) {
332
333        if ($objet = $flux['args']['objet']
334                and $id=intval($flux['args']['id_objet'])) {
335                // juste les publiés ?
336                if (array_key_exists('statut', $flux['args']) and ($flux['args']['statut'] == 'publie')) {
337                        $flux['data']['album'] = sql_countsel(
338                                'spip_albums AS D JOIN spip_albums_liens AS L ON D.id_album=L.id_album',
339                                'L.objet='.sql_quote($objet).'AND L.id_objet='.intval($id)." AND (D.statut='publie')"
340                        );
341                } else {
342                        $flux['data']['album'] = sql_countsel(
343                                'spip_albums AS D JOIN spip_albums_liens AS L ON D.id_album=L.id_album',
344                                'L.objet='.sql_quote($objet).'
345                                        AND L.id_objet='.intval($id)."
346                                        AND (D.statut='publie' OR D.statut='prepa')"
347                        );
348                }
349        }
350
351        return $flux;
352}
353
354
355/**
356 * Afficher le nombre d'albums liés dans la boîte infos des rubriques
357 *
358 * @pipeline boite_infos
359 *
360 * @param  array $flux Données du pipeline
361 * @return array       Données du pipeline
362 */
363function albums_boite_infos($flux) {
364
365        if ($flux['args']['type']=='rubrique'
366                and $id_rubrique = $flux['args']['id']) {
367                if ($nb = sql_countsel('spip_albums_liens', "objet='rubrique' AND id_objet=".intval($id_rubrique))) {
368                        $nb = '<div>'. singulier_ou_pluriel($nb, 'album:info_1_album', 'album:info_nb_albums') . '</div>';
369                        if ($p = strpos($flux['data'], '<!--nb_elements-->')) {
370                                $flux['data'] = substr_replace($flux['data'], $nb, $p, 0);
371                        }
372                }
373        }
374
375        return $flux;
376}
377
378
379/**
380 * Optimiser la base de donnée en supprimant les liens orphelins
381 *
382 * On supprime :
383 * - les albums à la poubelle
384 * - les liens obsolètes
385 *
386 * @pipeline optimiser_base_disparus
387 *
388 * @param  array $flux Données du pipeline
389 * @return array       Données du pipeline
390 */
391function albums_optimiser_base_disparus($flux) {
392
393        // albums à la poubelle
394        if (
395                isset($flux['args']['date']) and $flux['args']['date']
396                and is_array($ids_albums_poubelle = sql_allfetsel(
397                        'id_album',
398                        table_objet_sql('album'),
399                        "statut='poubelle' AND maj < ".$flux['args']['date']
400                ))) {
401                $ids_albums_poubelle = array_keys($ids_albums_poubelle);
402                include_spip('inc/albums');
403                supprimer_albums($ids_albums_poubelle);
404        }
405
406        // optimiser les liens morts entre documents et albums
407        include_spip('action/editer_liens');
408        $flux['data'] += objet_optimiser_liens(array('document'=>'*'), array('album'=>'*'));
409        $flux['data'] += objet_optimiser_liens(array('album' => '*'), '*');
410        return $flux;
411}
412
413
414/**
415 * Compléter ou modifier le résultat de la compilation des squelettes de certains formulaires.
416 *
417 * - Formulaire de configuration des documents :
418 *   insérer un message d'avertissement après le titre
419 *   au cas où l'ajout des documents aux albums est désactivé.
420 *
421 * @pipeline formulaire_fond
422 *
423 * @param  array $flux Données du pipeline
424 * @return array       Données du pipeline
425 */
426function albums_formulaire_fond($flux) {
427        if ($flux['args']['form'] == 'configurer_documents'
428                and $avertissement = albums_message_cfg_documents(true)) {
429                // On cherche titre du formulaire : <h3 class="titrem">...</h3>
430                // On le capture entièrement pour le faire suivre du message
431                $cherche = "/(<h3[^>]\s*class\s?=\s?['\"]titrem.*<\/h3>)/is";
432                $remplace = "$1$avertissement";
433                $flux['data'] = preg_replace($cherche, $remplace, $flux['data']);
434        }
435
436        return $flux;
437}
438
439
440/**
441 * Fonction privée qui retourne un message d'avertissement
442 * au cas où l'ajout de documents aux albums est désactivé.
443 *
444 * @param bool $baliser true pour baliser le texte avec <p>
445 * @return string|bool  le message d'avertissement, sinon false
446 */
447function albums_message_cfg_documents($baliser = false) {
448        $message = false;
449        $config = explode(',', $GLOBALS['meta']['documents_objets']);
450        $config = (is_array($config)) ? $config : array();
451        if (!in_array(table_objet_sql('album'), $config)) {
452                $message = _T('album:message_avertissement_cfg_documents');
453                if ($baliser) {
454                        $message=inserer_attribut(wrap($message, '<p>'), 'class', 'notice');
455                }
456        }
457
458        return $message;
459}
460
461
462/**
463 * Compléter le tableau de réponse ou effectuer des traitements supplémentaires pour certains formulaires.
464 *
465 * - Formulaire d'ajout de documents :
466 *   quand il s'agit d'un album, rechargement ajax du conteneur des documents.
467 *   On ajoute du js au message de retour.
468 *
469 * @note
470 * L'identifiant de l'album peut être négatif en cas de création
471 * cf. joindre_document.php, L.206 à 222
472 *
473 * Attention, il y a une différence dans les retours avant et après SPIP 3.0.17
474 * A partir de SPIP 3.0.17, on a les identifiants des documents ajoutés dans $flux['data']['ids]
475 * Avant, il faut les repérer à la main dans le message de retour.
476 *
477 * @pipeline formulaire_fond
478 *
479 * @param  array $flux Données du pipeline
480 * @return array       Données du pipeline
481 */
482function albums_formulaire_traiter($flux) {
483        if ($flux['args']['form'] == 'joindre_document'
484                and !intval($flux['args']['args'][0]) // nouveau document
485                and $flux['args']['args'][2] == 'album'
486                and $id_album = intval($flux['args']['args'][1])
487                and isset($flux['data']['message_ok']) // ajout = succès
488        ) {
489                // déterminer les identifiants des documents
490                // soit ils sont donnés dans $flux['data']['ids] (SPIP 3.0.17+)...
491                if (is_array($flux['data']['ids'])) {
492                        $ids_documents = $flux['data']['ids'];
493                } else {
494                        // ...soit il faut les récupérer à la main d'après le message de retour
495                        // dans le callback du script dans le message, on a les identifiants des divs #docX
496                        $reg = '/#doc(\d*)/';
497                        preg_match_all($reg, $flux['data']['message_ok'], $matches);
498                        $ids_documents = is_array($matches[1]) ? array_unique($matches[1]) : array();
499                }
500                // en callback, animation de chaque document ajouté (#documentX_albumY)
501                if (count($ids_documents)) {
502                        $divs_documents = array();
503                        foreach ($ids_documents as $id_document) {
504                                $divs_documents[] = "#document${id_document}-album${id_album}";
505                        }
506                        $divs_documents = implode(',', $divs_documents);
507                        $callback = "jQuery('$divs_documents').animateAppend();";
508                }
509                // rechargement du conteneur des documents de l'album
510                // id du conteneur : «#documents-albumY»
511                $js = "if (window.jQuery) jQuery(function(){ajaxReload('documents-album$id_album',{callback:function(){ $callback }});});";
512                $js = "<script type='text/javascript'>$js</script>";
513                if (isset($flux['data']['message_erreur'])) {
514                        $flux['data']['message_erreur'].= $js;
515                } else {
516                        $flux['data']['message_ok'] .= $js;
517                }
518        }
519
520        return $flux;
521}
522
523
524/**
525 * Compléter ou modifier la liste des messages des compagnons.
526 *
527 * - Page «albums» : présentation succinte des albums & explication des filtres latéraux.
528 *
529 * @pipeline compagnon_messages
530 *
531 * @param  array $flux Données du pipeline
532 * @return array       Données du pipeline
533 */
534function albums_compagnon_messages($flux) {
535
536        $exec     = $flux['args']['exec'];
537        $pipeline = $flux['args']['pipeline'];
538        $vus      = $flux['args']['deja_vus'];
539        $aides    = &$flux['data'];
540
541        switch ($pipeline) {
542                case 'affiche_milieu':
543                        switch ($exec) {
544                                case 'albums':
545                                        if (!isset($vus['albums'])) {
546                                                $aides[] = array(
547                                                        'id' => 'albums',
548                                                        'titre' => _T('album:c_albumotheque_titre_presentation'),
549                                                        'texte' => _T('album:c_albumotheque_presentation'),
550                                                        'statuts'=> array('1comite', '0minirezo', 'webmestre'),
551                                                        'target'=> '.albumotheque .entete h2',
552                                                );
553                                                $aides[] = array(
554                                                        'id' => 'albums',
555                                                        'titre' => _T('album:c_albumotheque_titre_filtres'),
556                                                        'texte' => _T('album:c_albumotheque_filtres'),
557                                                        'statuts'=> array('1comite', '0minirezo', 'webmestre'),
558                                                        'target'=> '#navigation .navigation-albums',
559                                                );
560                                        }
561                                        break;
562                        }
563                        break;
564        }
565
566        return $flux;
567}
568
569
570/**
571 * Utilisation du pipeline album_boutons_actions
572 *
573 * Renvoie une liste des boutons d'actions des albums.
574 * Ils sont affichés dans les listes d'albums (footer), ou sur la fiche d'un album (boîte infos latérale).
575 * Cette liste est un tableau associatif,
576 * donc les plugins peuvent ajouter les leurs mais également modifier certaines entrées (voir note).
577 *
578 * @note
579 * `$flux['data']` est un tableau associatif de la forme `identifiant de l'action => code HTML du bouton`.
580 * Les identifiants sont à priori des verbes : «vider», «supprimer», «giboliner», etc.
581 * Ça permet, en plus de compléter la liste, d'avoir la main sur des entrées précises.
582 * ````
583 * array(
584 *     'dissocier' => 'code HTML'
585 *     'vider'     => 'code HTML'
586 * )
587 * ````
588 *
589 * @pipeline album_boutons_actions
590 * @param array $flux
591 *     Données du pipeline
592 *     $flux['data']                array     tableau associatif des boutons
593 *     $flux['args']['id_album']    int       identifiant de l'album
594 *                  ['position']    string    endroit où sont affichés les boutons : footer | boite_infos
595 *                  ['objet']       string    type d'objet pour un album associé
596 *                  ['id_objet']    int       identifiant de l'objet
597 * @return array
598 *     Données du pipeline
599**/
600function albums_album_boutons_actions($flux) {
601
602        if (!function_exists('bouton_action')) {
603                include_spip('inc/filtres');
604        }
605        if (!function_exists('generer_action_auteur')) {
606                include_spip('inc/actions');
607        }
608        if (!function_exists('autoriser')) {
609                include_spip('inc/autoriser');
610        }
611
612        $data = (is_array($flux['data']) and count($flux['data'])) ? $flux['data'] : array();
613        $id_album = intval($flux['args']['id_album']);
614        $position = (isset($flux['args']['position']) and in_array($flux['args']['position'], array('footer', 'boite_infos'))) ? $flux['args']['position'] : null;
615        $objet    = (isset($flux['args']['objet'])) ? $flux['args']['objet'] : '';
616        $id_objet = (isset($flux['args']['id_objet']) and intval($flux['args']['id_objet'])) ? $flux['args']['id_objet'] : '';
617        $liaison  = ($objet and $id_objet) ? true : false;
618
619        // liste de tous les boutons possibles
620        // `positions` indique les positions où ils peuvent apparaître (footer ou boite_infos)
621        // `liaison`   indique qu'il faut afficher le bouton uniquement en cas de liaison (on a $objet et $id_objet)
622        // `html`      code html du bouton
623        $boutons = array(
624                'dissocier' => array(
625                        'positions' => array('footer'),
626                        'liaison'   => true,
627                        'autoriser' => autoriser('dissocier', 'album', $id_album, '', array('objet'=>$objet, 'id_objet'=>$id_objet)),
628                        'html'      => bouton_action(
629                                _T('album:bouton_dissocier'),
630                                generer_action_auteur('dissocier_album', $id_album.'/'.$objet.'/'.$id_objet, self()),
631                                'ajax dissocier',
632                                '',
633                                _T('album:bouton_dissocier_explication'),
634                                '(function(){jQuery("#album$id_album").animateRemove();return true;})()'
635                        )
636                ),
637                'supprimer' => array(
638                        'positions' => array('footer','boite_infos'),
639                        'liaison'   => false,
640                        'autoriser' => autoriser('supprimer', 'album', $id_album),
641                        'html'      => bouton_action(
642                                _T('album:bouton_supprimer'),
643                                generer_action_auteur('supprimer_album', $id_album, _request('exec') == 'album' ? generer_url_ecrire('albums'): self()),
644                                _request('exec') == 'album' ? 'supprimer': 'ajax supprimer',
645                                _T('album:message_supprimer'),
646                                _T('album:bouton_supprimer_explication'),
647                                _request('exec') == 'album' ? '':'(function(){jQuery("#album$id_album").animateRemove();return true;})()'
648                        )
649                ),
650                'vider' => array(
651                        'positions' => array('footer','boite_infos'),
652                        'liaison'   => false,
653                        'autoriser' => autoriser('vider', 'album', $id_album),
654                        'html'      => bouton_action(
655                                _T('album:bouton_vider'),
656                                generer_action_auteur('vider_album', "$id_album", self()),
657                                'ajax vider',
658                                '',
659                                _T('album:bouton_vider_explication')
660                        )
661                ),
662                /*'transvaser' => array(
663                        'positions' => array('footer'),
664                        'liaison'   => true,
665                        'autoriser' => (autoriser('transvaser','album',$id_album,'',array('objet'=>$objet,'id_objet'=>$id_objet))) ? true : false,
666                        'html'      => bouton_action(
667                                _T('album:bouton_transvaser'),
668                                generer_action_auteur('transvaser_album',"$id_album/$objet/$id_objet/false/true",self()),
669                                'ajax transvaser',
670                                '',
671                                _T('album:bouton_transvaser_explication'),
672                                '(function(){ajaxReload("documents");return true;})()'
673                        )
674                ),*/
675                'remplir' => array(
676                        'positions' => array('footer'),
677                        'liaison' => '',
678                        'autoriser' => autoriser('modifier', 'album', $id_album),
679                        'html' => '<a href="#" class="bouton remplir" role="button" tabindex="0">'._T('medias:bouton_ajouter_document').'</a>'
680                ),
681        );
682
683        // liste des boutons affichés en fonction des autorisations et du contexte
684        $boutons_affiches = array();
685        foreach (array_keys($boutons) as $k) {
686                if (is_null($position) ? !$position : in_array($position, $boutons[$k]['positions'])
687                        and $boutons[$k]['liaison'] ? $boutons[$k]['liaison'] === $liaison : !$boutons[$k]['liaison']
688                        and $boutons[$k]['autoriser'] === true) {
689                        $boutons_affiches[$k] = $boutons[$k]['html'];
690                }
691        }
692
693        $data = array_merge($data, $boutons_affiches);
694        $flux['data'] = $data;
695
696        return $flux;
697}
698
699
700/**
701 * Modifier le résultat du calcul d'un squelette
702 *
703 * - Squelette «inc-upload_documents» : si utilisé pour un album,
704 * ajout d'un suffixe unique à l'id du conteneur principal (et à ses références dans le js et cie),
705 * afin de pouvoir utiliser le formulaire plusieurs fois sur une même page.
706 * Quand utilisé dans le formulaire d'ajout d'album, on change le texte des boutons.
707 *
708 * @pipeline recuperer_fond
709 *
710 * @param  array $flux Données du pipeline
711 * @return array       Données du pipeline
712 */
713function albums_recuperer_fond($flux) {
714
715        if (isset($flux['args']['fond'])
716                and $fond = $flux['args']['fond']
717                and $fond == 'formulaires/inc-upload_document'
718                and isset($flux['args']['contexte']['objet'])
719                and $flux['args']['contexte']['objet'] == 'album'
720                //and isset($flux['args']['contexte']['form'])
721                //and in_array($flux['args']['contexte']['form'], array('joindre_document', 'ajouter_album'))
722        ) {
723                // Changer l'identifiant du conteneur
724                // Définition de l'identifiant dans le squelette : _#ENV{mode}|concat{'_',#ENV{id,new}}
725                $texte = $flux['data']['texte'];
726                $mode = isset($flux['args']['contexte']['mode']) ?
727                        $flux['args']['contexte']['mode'] :
728                        '';
729                $id = (isset($flux['args']['contexte']['id']) and intval($flux['args']['contexte']['id']) > 0) ?
730                        $flux['args']['contexte']['id'] :
731                        'new';
732                $domid = '_' . $mode . '_' . $id;
733                $dom_uniqid = $domid . uniqid('_');
734                $flux['data']['texte'] = str_replace($domid, $dom_uniqid, $texte);
735
736                // Remplacer le texte des boutons dans le formulaire « ajouter_album »
737                if (isset($flux['args']['contexte']['form'])
738                        and $flux['args']['contexte']['form'] == 'ajouter_album'
739                ) {
740                        $enregistrer = _T('bouton_enregistrer');
741                        $cherche = array(
742                                _T('bouton_upload'),
743                                _T('medias:bouton_attacher_document'),
744                                _T('bouton_choisir'),
745                        );
746                        $flux['data']['texte'] = str_replace($cherche, $enregistrer, $texte);
747                }
748        }
749
750        return $flux;
751}
Note: See TracBrowser for help on using the repository browser.