Discussion :

[Dark_fun]

Bonjour à tous,

j'ai crée différent blocks que j'affiche sur mon dashboard. J'aimerai contrôler le chargement de ces blocks en fonction de la personne connecté, plus précisément en fonction de son rôle.

Exemple : Si un Admin est connecté, je veux afficher les blocks 1,4 et 8 et si un utilisateur lambda les block 2, 3 et 5.

Est ce que quelqu'un aurait un exemple sur comment faire ?

Voici une partie de mon fichier config.yml où mes différent block sont déclarés :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
sonata_block:
    default_contexts: [cms]
    blocks:
        sonata.admin.block.admin_list:
            contexts:   [admin]
 
        #sonata.admin_doctrine_orm.block.audit:
        #    contexts:   [admin]
 
        sonata.admin.block.search_result:
            contexts: [admin]
 
        # Some specific block from the SonataMediaBundle
        #sonata.media.block.media:
        #sonata.media.block.gallery:
        #sonata.media.block.feature_media:
 
        sonata.user.block.menu:
            contexts: [admin]    # used to display the menu in profile pages
        sonata.user.block.account: # used to display menu option (login option)
        sonata.block.service.text: ~
        sonata.block.service.rss: ~
        sonata.block.service.graph:
        sonata.block.service.listuser:
        sonata.block.service.infouser: ~
        sonata.block.service.backupuser: ~

Services.yml :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
sonata.block.service.graph:
    class: Akylon\BackOfficeBundle\Block\GraphBlockService
    arguments: [ "sonata.block.service.graph", @templating ]
    tags:
        - { name: sonata.block }
 
sonata.block.service.listuser:
    class: Application\Sonata\UserBundle\Block\UserListBlockService
    arguments: [ "sonata.block.service.listuser", @templating, @sonata.admin.pool, @doctrine.orm.entity_manager, @security.context]
    tags:
        - { name: sonata.block}
 
sonata.block.service.infouser:
    class: Application\Sonata\UserBundle\Block\UserInfoBlockService
    arguments: [ "sonata.block.service.infouser", @templating, @sonata.admin.pool, @doctrine.orm.entity_manager, @security.context]
    tags:
        - { name: sonata.block}
 
sonata.block.service.backupuser:
    class: Application\Sonata\UserBundle\Block\UserBackupBlockService
    arguments: [ "sonata.block.service.backupuser", @templating, @sonata.admin.pool, @doctrine.orm.entity_manager, @security.context]
    tags:
        - { name: sonata.block}

L'un de mes block :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
<?php
 
namespace Application\Sonata\UserBundle\Block;
 
use Sonata\BlockBundle\Block\BlockContextInterface;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Bundle\FrameworkBundle\Templating\EngineInterface;
 
use Sonata\AdminBundle\Form\FormMapper;
use Sonata\AdminBundle\Validator\ErrorElement;
use Sonata\AdminBundle\Admin\Pool;
use Sonata\AdminBundle\Admin\AdminInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Security\Core\SecurityContextInterface;
 
use Sonata\BlockBundle\Model\BlockInterface;
use Sonata\BlockBundle\Block\BaseBlockService;
use Symfony\Component\Security\Core\SecurityContext;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\OptionsResolver\OptionsResolverInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Doctrine\ORM\EntityManager;
 
class UserInfoBlockService extends BaseBlockService
{
    /**
     * @var SecurityContextInterface
     */
    protected $securityContext;
 
    /**
     * @var Pool
     */
    protected $pool;
 
    /**
     * @var EntityManager
     */
    protected $em;
 
    public function __construct($name, EngineInterface $templating, Pool $pool, EntityManager $em, SecurityContext $securityContext)
    {
        parent::__construct($name, $templating);
 
        $this->pool = $pool;
        $this->em = $em;
        $this->securityContext = $securityContext;
    }
 
    /**
     * {@inheritdoc}
     */
    public function getName()
    {
        return 'Mes informations';
    }
 
 
    /**
     * {@inheritdoc}
     */
    public function execute(BlockContextInterface $blockContext, Response $response = null)
    {
        $user_current   = $this->securityContext->getToken()->getUser();
        $idUser         = $user_current->getId();
 
 
            $userPost = $this->em->getRepository('BackOfficeBundle:Post')
                                 ->findByUser($user_current);
            $user     = $this->em->getRepository("ApplicationSonataUserBundle:User")
                                 ->findOneById($idUser);
 
        // merge settings
        $settings = array_merge($this->getDefaultSettings(), $blockContext->getSettings());
 
        return $this->renderResponse($blockContext->getTemplate(), array(
                        'block'         => $blockContext->getBlock(),
                        'base_template' => $this->pool->getTemplate('layout'),
                        'user'          => $user,
                        'userPost'      => $userPost,
                        'settings'      => $blockContext->getSettings()
                     ), $response);
    }
    /**
     * {@inheritdoc}
     */
    public function setDefaultSettings(OptionsResolverInterface $resolver)
    {
        $resolver->setDefaults(array(
            'title'    => 'Mes informations',
            'template' => 'ApplicationSonataUserBundle:Block:userInfoDashboard.html.twig'
        ));
    }
 
    public function getDefaultSettings()
    {
        return array();
    }
 
    /**
     * {@inheritdoc}
     */
    public function validateBlock(ErrorElement $errorElement, BlockInterface $block)
    {
    }
 
    /**
     * {@inheritdoc}
     */
    public function buildEditForm(FormMapper $formMapper, BlockInterface $block)
    {
 
    }
}

Merci d'avance !

[arnooo999]

Bonjour,

s'il s'agit d'afficher/masquer l'ensemble du block en fonction des roles, pourquoi ne peux-tu pas le faire au niveau de la template twig globale?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
// dashboard.html.twig
 
{%block container %}
 
  {%if is_granted('ROLE_ADMIN' %}
     {{ sonata_block_render({ 'type': 'sonata.admin.block.admin_list' }) }}
  {%endif%}
 
  {## etc... ##}
 
{%endblock%}

[Dark_fun]

Bonjour Arno,

Merci pour ta réponse !
ça donne ce que je souhaite.
Je pensais qu'il y aurait une façon plus souple de faire. Notamment dans le fichier config.yml.

Si jamais quelqu'un à une autre solution je suis preneur !

Merci encore

[Nico_F]

Hello,

Je partage l'avis d'arnoooo999, l'utilisation du css me semble relativement efficace.

Maintenant j'ai une autre solution qui me vient à l'esprit mais qui est plus lourde et contraignante, je ne sais pas si Sonata le permet.
Pour une situation plus ou moins comparable, j'ai du mettre en place un système d'évènements, et ce sont les subscribers d'évènement qui se chargeaient de construire ce dont j'avais besoin (dans ton cas, la collection de blocks pour l'admin).

Globalement tu ne fais que déclencher un évènement dashboard_build auquel est abonné un Subscriber DashboardAddBlock. Peut-être que SonataAdmin possède déjà ce type d'évènement je n'en sais rien. C'est alors le subscriber qui va construire ton admin.
En injectant le securityContext au subscriber et en récupérant tous les blocks possibles, tu peux alors boucler sur tes blocks et n'ajouter à la collection de block admin que ceux pour lequel le user connecté a accès.

Je ne connais pas du tout SonataAdmin donc c'est un tir à l'aveuglette, mais si ça peut te donner des idées...

++