Mon formulaire ne s'affiche pas, error: "array to string conversion" SF4

Version imprimable

Bonjour,

Je créé un formulaire d'inscription à la main, donc à la fin de mon controller je passe un tableau en param du render, ce qui fait que dans ma vue twig associée,
le process ne supporte pas le {{ form_start(form) }} ni le {{ form_end(form) }} ou encore le {{ form_widget(form) }}.

Si j'enlève ces balises et je met seulement {{ form_row(form.username) }} par exemple, cela fonctionne mais le formulaire n'est pas traité.

Je souhaiterai pouvoir construire mon formulaire normalement, avec un {{ form_start(form) }} et un {{ form_end(form) }}.

Erreur exacte :

Citation:

An exception has been thrown during the rendering of a template ("Notice: Array to string conversion").

Controller :

Code:

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
    /**
     * @param Request $request
     * @param UserPasswordEncoderInterface $passwordEncoder
     * @return \Symfony\Component\HttpFoundation\RedirectResponse|Response
     * @Route("/createUser", name="create_user")
     */
    public function createUser(Request $request, UserPasswordEncoderInterface $passwordEncoder)
    {
        //building form
        $user = new User();
        $form = $this->createForm(UserType::class, $user);
 
        //handle the submit
        $form->handleRequest($request);
 
        if ($form->isSubmitted() && $form->isValid()) {
            //encode the password
            $password = $passwordEncoder->encodePassword($user, $user->getPassword());
            $user->setPassword($password);
 
            //save user
            $em = $this->getDoctrine()->getManager();
            $em->persist($user);
            $em->flush();
 
            return $this->redirectToRoute('gestion');
        }
        $formView = $form->createView();
        return $this->render('admin/register.html.twig', ['form' => $formView]);
    }

Layout :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{% extends 'base.html.twig' %}
 
{% block body %}
 
    {{ form_start(form) }}
 
    {{ form_row(form.username) }}
    {{ form_row(form.email) }}
    {{ form_row(form.password) }}
    <button type="submit">Register!</button>
 
    {{ form_end(form) }}
 
{% endblock %}

Merci pour votre aide

05/06/2018, 16h28
armel18
L'erreur ne se trouve pas dans la vue twig mais plus loin car ces 2 helpers form_end(form) et form_widget(form) ne font que le rendu de tous les éléments du formulaire(y compris des champs cachés) qui n'ont pas été spécifiés dans la vue twig mais qui se trouvent dans le UserType.

La cause la plus plausible de cette erreur est que tu tentes d'associer une propriété( de type string) de l'entity User à un champ du formulaire n'acceptant que des array comme le champ de type ChoiceType. Au vue de ton code je présume que cette propriété est bien rôles. Il faut donner à la propriété rôles le type array ou json_array ( mysql 5.7+):
Code:

1 2 3 4 5 /** * @ORM\Column(type="array") */ private $roles = [];

Hello, merci de ta réponse Armel.

Je n'ai pas de spécification dans mon champ rôle du form UserType

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('fullname', TextType::class)
            ->add('username', TextType::class)
            ->add('company', TextType::class)
            ->add('password', PasswordType::class)
            ->add('email', EmailType::class)
            ->add('supportTime', TimeType::class)
            ->add('isActive')
            ->add('roles');
    }

J'ai bien un Json Array pour les roles..

Code:

1
2
3
4
5
6
    /**
     * @var array
     *
     * @ORM\Column(type="json")
     */
    private $roles = [];

J'ai aussi essayé avec un nouveau form, d'une entité des plus basique et c'est la même chose.
Il ne veut pas de 'form' en paramètre des {{ form_start }} {{ form_end }} ou form_quoiquecesoit

Citation:

Citation:

/**
* @var array
*
* @ORM\Column(type="json")
*/
private $roles = [];

Le type json n'existe pas(cf. mon post précédent), par contre json_array existe mais n'utilise ce type que si t'es sûr que tu as mysql 5.7+ ou mariaDB sinon le type array fait bien le taf.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 //User.php /** * @ORM\Column(type="array") */ private $roles = [] public function getRoles(): array { $roles = $this->roles; $roles[] = 'ROLE_USER'; return array_unique($roles); } //setRoles( array roles)
et dans le UserType, il faut donner à la liste déroulante un tableau de rôles:
Code:

1 2 3 4 5 6 7 8 9 10 use Symfony\Component\Form\Extension\Core\Type\ChoiceType; $builder ->add('roles', ChoiceType::class, [ 'choices' => [ 'Admin' => 'ROLE_ADMIN', 'Super' => 'ROLE_SUPER_ADMIN', ], ])
si l'erreur persiste , il faut poster la classe User et UserType en intégralité.

Bonjour Armel,

L'erreur persiste, je tiens à préciser qu'elle a légèrement changée.
Erreur : "Notice: Array to string conversion" ==> plus direct.

J'ai aussi modifié mes fichiers, comme mon entité par exemple mais le pb reste sur le champ rôle. Sans ce champ, ça fonctionne.

J'ai fais les modifications, je colle mon form et mon entité :

Form UserType :

Code:

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
<?php
 
namespace App\Form;
 
use App\Entity\User;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
use Symfony\Component\Form\Extension\Core\Type\EmailType;
use Symfony\Component\Form\Extension\Core\Type\PasswordType;
use Symfony\Component\Form\Extension\Core\Type\RepeatedType;
use Symfony\Component\Form\Extension\Core\Type\SubmitType;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\Extension\Core\Type\TimeType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;
 
class UserType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('username', TextType::class)
            ->add('support_time', TimeType::class)
            ->add('company', TextType::class)
            ->add('email', EmailType::class)
            ->add('roles', ChoiceType::class, [
                'choices' => [
                    'Admin' => 'ROLE_ADMIN',
                    'Super' => 'ROLE_SUPER_ADMIN',
                ],
            ])
            ->add('plainPassword', RepeatedType::class, array(
                'type' => PasswordType::class,
                'first_options' => array('label' => 'Mot de passe'),
                'second_options' => array('label' => 'Confirmation du mot de passe'),
            ))
            ->add('submit', SubmitType::class, ['label' => 'Envoyer', 'attr' => ['class' => 'btn-primary btn-block']]);
    }
 
    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'data_class' => User::class,
        ]);
    }
}

Entité User :

Code:

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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
<?php
 
namespace App\Entity;
 
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Security\Core\User\AdvancedUserInterface;
use Symfony\Component\Validator\Constraints as Assert;
 
/**
 * @ORM\Entity(repositoryClass="App\Repository\UserRepository")
 */
class User implements AdvancedUserInterface, \Serializable
{
    /**
     * @ORM\Id()
     * @ORM\GeneratedValue()
     * @ORM\Column(type="integer")
     */
    private $id;
    /**
     * @ORM\Column(type="string", length=255, unique=true)
     * @Assert\NotBlank()
     * @Assert\Email()
     */
    private $email;
 
    /**
     * @Assert\NotBlank()
     * @Assert\Length(max=250)
     */
    private $plainPassword;
 
    /**
     * The below length depends on the "algorithm" you use for encoding
     * the password, but this works well with bcrypt.
     *
     * @ORM\Column(type="string", length=64)
     */
    private $password;
 
    /**
     * @ORM\Column(name="is_active", type="boolean")
     */
    private $isActive;
 
    /**
     * @ORM\Column(name="roles", type="array")
     */
    private $roles = array();
 
    /**
     * @ORM\Column(type="string", length=35)
     */
    private $username;
 
    /**
     * @ORM\Column(type="time")
     */
    private $support_time;
 
    /**
     * @ORM\Column(type="string", length=150)
     */
    private $company;
 
    public function __construct()
    {
        $this->isActive = true;
        // may not be needed, see section on salt below
        // $this->salt = md5(uniqid('', true));
    }
 
    public function getUsername()
    {
        return $this->email;
    }
 
    public function getSalt()
    {
        // you *may* need a real salt depending on your encoder
        // see section on salt below
        return null;
    }
 
    public function getPassword()
    {
        return $this->password;
    }
 
    function setPassword($password)
    {
        $this->password = $password;
    }
 
    public function getRoles(): array
    {
        $roles = $this->roles;
        $roles[] = 'ROLE_USER';
        return array_unique($roles);
    }
 
    function addRoles($roles)
    {
        $this->roles[] = $roles;
    }
 
    public function eraseCredentials()
    {
 
    }
 
    /** @see \Serializable::serialize() */
    public function serialize()
    {
        return serialize(array(
            $this->id,
            $this->email,
            $this->password,
            $this->isActive,
            // see section on salt below
            // $this->salt,
        ));
    }
 
    /** @see \Serializable::unserialize() */
    public function unserialize($serialized)
    {
        list (
            $this->id,
            $this->email,
            $this->password,
            $this->isActive,
            // see section on salt below
            // $this->salt
            ) = unserialize($serialized);
    }
 
    public function isAccountNonExpired()
    {
        return true;
    }
 
    public function isAccountNonLocked()
    {
        return true;
    }
 
    public function isCredentialsNonExpired()
    {
        return true;
    }
 
    public function isEnabled()
    {
        return $this->isActive;
    }
 
    function getId()
    {
        return $this->id;
    }
 
    function getEmail()
    {
        return $this->email;
    }
 
    function getPlainPassword()
    {
        return $this->plainPassword;
    }
 
    function getIsActive()
    {
        return $this->isActive;
    }
 
    function setId($id)
    {
        $this->id = $id;
    }
 
    function setEmail($email)
    {
        $this->email = $email;
    }
 
    function setPlainPassword($plainPassword)
    {
        $this->plainPassword = $plainPassword;
    }
 
    function setIsActive($isActive)
    {
        $this->isActive = $isActive;
    }
 
    public function setUsername(string $username): self
    {
        $this->username = $username;
 
        return $this;
    }
 
    public function getSupportTime(): ?\DateTimeInterface
    {
        return $this->support_time;
    }
 
    public function setSupportTime(\DateTimeInterface $support_time): self
    {
        $this->support_time = $support_time;
 
        return $this;
    }
 
    public function getCompany(): ?string
    {
        return $this->company;
    }
 
    public function setCompany(string $company): self
    {
        $this->company = $company;
 
        return $this;
    }
}

De nouveau merci pour tes réponses.

désolé j'avais pas mis toutes options pour la création d'une liste déroulante. 2 choix sont possibles pour créer une liste déroulantes.
Choix 1 : cas d'une liste déroulante à choix multiple

Code:

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
 
<?php
 
namespace App\Form;
 
use App\Entity\User;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
use Symfony\Component\Form\Extension\Core\Type\EmailType;
use Symfony\Component\Form\Extension\Core\Type\PasswordType;
use Symfony\Component\Form\Extension\Core\Type\RepeatedType;
use Symfony\Component\Form\Extension\Core\Type\SubmitType;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\Extension\Core\Type\TimeType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;
 
class UserType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('username', TextType::class)
            ->add('support_time', TimeType::class)
            ->add('company', TextType::class)
            ->add('email', EmailType::class)
            ->add('roles', ChoiceType::class, [
              'choices' => [
                  'Admin' => 'ROLE_ADMIN',
                  'Super' => 'ROLE_SUPER_ADMIN',
              ],
              'expanded'  => false, // liste déroulante
              'multiple'  => true, // choix multiple
          ])
            ->add('plainPassword', RepeatedType::class, array(
                'type' => PasswordType::class,
                'first_options' => array('label' => 'Mot de passe'),
                'second_options' => array('label' => 'Confirmation du mot de passe'),
            ))
            ->add('submit', SubmitType::class, ['label' => 'Envoyer', 'attr' => ['class' => 'btn-primary btn-block']]);
    }
 
    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'data_class' => User::class,
        ]);
    }
}

Choix 2 : cas d'une liste déroulante à choix unique

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
use Symfony\Component\Form\Extension\Core\Type\CollectionType;
 
//...
 ->add('roles', CollectionType::class, [
            'entry_type'   => ChoiceType::class,
            'entry_options'  => [
                'label' => false,
                'choices' => [
                    'Admin' => 'ROLE_ADMIN',
                    'Super' => 'ROLE_SUPER_ADMIN',
                ],
            ],
  ])

Après vérification de la doc doctrine 2, le type json existe à partir de la version 2.7 de doctrine, contrairement ce que j'ai énoncé précédemment.

07/06/2018, 10h11
Torej

Salut Armel,

Oui en effet, il me semblait bien que ce typage existait vu que je l'ai vu en console en créant mon entité.

Bref, tout est rentré dans l'ordre avec la seconde méthode ( la première a aussi fonctionné ).

Merci pour ton aide et bonne continuation.

Bonjour Armel,

Nouveau rebondissement dans l'affaire du tableau de rôles..
Je n'arrive pas à connecter un utilisateur admin.

Explication : Lorsqu'au moment de l'inscription je met "user" dans ma liste déroulante correspondant au rôle, j'ai, dans ma colonne SQL:
"a:0:{}"
et j'arrive à me connecter. J'ai mis un "Bonjour {{app.user.roles[0]}}" dans ma vue pour vérifier, qui me ressort "Bonjour ROLE_USER" sur la page du site.

Par contre quand je met "admin" dans ma liste déroulante j'ai dans ma colonne SQL:
"a:1:{i:0;a:1:{i:0;s:10:"ROLE_ADMIN";}}"
et j'ai une erreur Symfony après la connexion qui est "Notice: Array to string conversion".

Je fournis la construction de mon form et de mon user.

Form :

Code:

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
<?php
 
namespace App\Form;
 
use App\Entity\User;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
use Symfony\Component\Form\Extension\Core\Type\CollectionType;
use Symfony\Component\Form\Extension\Core\Type\EmailType;
use Symfony\Component\Form\Extension\Core\Type\PasswordType;
use Symfony\Component\Form\Extension\Core\Type\RepeatedType;
use Symfony\Component\Form\Extension\Core\Type\SubmitType;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\Extension\Core\Type\TimeType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;
 
class UserType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('username', TextType::class)
            ->add('support_time', TimeType::class)
            ->add('company', TextType::class)
            ->add('email', EmailType::class)
            ->add('roles', CollectionType::class, [
                'entry_type' => ChoiceType::class,
                'entry_options' => [
                    'label' => false,
                    'choices' => [
                        'User' => 'ROLE_USER',
                        'Admin' => 'ROLE_ADMIN',
                    ],
                ],
            ])
            ->add('plainPassword', RepeatedType::class, array(
                'type' => PasswordType::class,
                'first_options' => array('label' => 'Mot de passe'),
                'second_options' => array('label' => 'Confirmation du mot de passe'),
            ))
            ->add('submit', SubmitType::class, ['label' => 'Envoyer', 'attr' => ['class' => 'btn-primary btn-block']]);
    }
 
    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'data_class' => User::class,
        ]);
    }
}

User :

Code:

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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
<?php
 
namespace App\Entity;
 
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Security\Core\User\AdvancedUserInterface;
use Symfony\Component\Validator\Constraints as Assert;
 
/**
 * @ORM\Entity(repositoryClass="App\Repository\UserRepository")
 */
class User implements AdvancedUserInterface, \Serializable
{
    /**
     * @ORM\Id()
     * @ORM\GeneratedValue()
     * @ORM\Column(type="integer")
     */
    private $id;
    /**
     * @ORM\Column(type="string", length=255, unique=true)
     * @Assert\NotBlank()
     * @Assert\Email()
     */
    private $email;
 
    /**
     * @Assert\NotBlank()
     * @Assert\Length(max=250)
     */
    private $plainPassword;
 
    /**
     * The below length depends on the "algorithm" you use for encoding
     * the password, but this works well with bcrypt.
     *
     * @ORM\Column(type="string", length=64)
     */
    private $password;
 
    /**
     * @ORM\Column(name="is_active", type="boolean")
     */
    private $isActive;
 
    /**
     * @ORM\Column(name="roles", type="array")
     */
    private $roles = array();
 
    /**
     * @ORM\Column(type="string", length=35)
     */
    private $username;
 
    /**
     * @ORM\Column(type="time")
     */
    private $support_time;
 
    /**
     * @ORM\Column(type="string", length=150)
     */
    private $company;
 
    public function __construct()
    {
        $this->isActive = true;
        // may not be needed, see section on salt below
        // $this->salt = md5(uniqid('', true));
    }
 
    public function getUsername()
    {
        return $this->email;
    }
 
    public function getSalt()
    {
        // you *may* need a real salt depending on your encoder
        // see section on salt below
        return null;
    }
 
    public function getPassword()
    {
        return $this->password;
    }
 
    function setPassword($password)
    {
        $this->password = $password;
    }
 
    public function getRoles(): array
    {
        $roles = $this->roles;
        $roles[] = 'ROLE_USER';
        return array_unique($roles);
    }
 
    function setRoles($roles)
    {
        $this->roles[] = $roles;
    }
 
    public function eraseCredentials()
    {
 
    }
 
    /** @see \Serializable::serialize() */
    public function serialize()
    {
        return serialize(array(
            $this->id,
            $this->email,
            $this->password,
            $this->isActive,
            // see section on salt below
            // $this->salt,
        ));
    }
 
    /** @see \Serializable::unserialize() */
    public function unserialize($serialized)
    {
        list (
            $this->id,
            $this->email,
            $this->password,
            $this->isActive,
            // see section on salt below
            // $this->salt
            ) = unserialize($serialized);
    }
 
    public function isAccountNonExpired()
    {
        return true;
    }
 
    public function isAccountNonLocked()
    {
        return true;
    }
 
    public function isCredentialsNonExpired()
    {
        return true;
    }
 
    public function isEnabled()
    {
        return $this->isActive;
    }
 
    function getId()
    {
        return $this->id;
    }
 
    function getEmail()
    {
        return $this->email;
    }
 
    function getPlainPassword()
    {
        return $this->plainPassword;
    }
 
    function getIsActive()
    {
        return $this->isActive;
    }
 
    function setId($id)
    {
        $this->id = $id;
    }
 
    function setEmail($email)
    {
        $this->email = $email;
    }
 
    function setPlainPassword($plainPassword)
    {
        $this->plainPassword = $plainPassword;
    }
 
    function setIsActive($isActive)
    {
        $this->isActive = $isActive;
    }
 
    public function setUsername(string $username): self
    {
        $this->username = $username;
 
        return $this;
    }
 
    public function getSupportTime(): ?\DateTimeInterface
    {
        return $this->support_time;
    }
 
    public function setSupportTime(\DateTimeInterface $support_time): self
    {
        $this->support_time = $support_time;
 
        return $this;
    }
 
    public function getCompany(): ?string
    {
        return $this->company;
    }
 
    public function setCompany(string $company): self
    {
        $this->company = $company;
 
        return $this;
    }
}

Citation:

Par contre quand je met "admin" dans ma liste déroulante j'ai dans ma colonne SQL:
"a:1:{i:0;a:1:{i:0;s:10:"ROLE_ADMIN";}}"
et j'ai une erreur Symfony après la connexion qui est "Notice: Array to string conversion".

parce que tu tentes d'afficher un tableau ( un peu comme si tu faisais echo ["toto"]). Or ROLE_ADMIN se trouve dans un sous tableau, donc pour le recupérer dans la vue:
Code:

1 2 3 4 app.user.roles[0][0]; {# tu peux déboguer pour voir le contenu du tableau roles: #} {{ dump( app.user.roles ) }}
Après je peux comprendre qu'il est un peu embêtant que pour accéder à un rôle il faut passer par un sous tableau d'un tableau( quoique on peut tjrs boucler ). Pour éviter de se retrouver avec un sous tableau par rôle, tu peux modifier la méthode setRoles() de la classe User de sorte que cette méthode ajoute juste un rôle en tant que string et non en tant array:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 /** * @ORM\Entity(repositoryClass="App\Repository\UserRepository") */ class User implements AdvancedUserInterface, \Serializable { function setRoles( array $roles ) { $this->roles[] = current( $roles ); // on extrait le 1er rôle du tabelau $roles passés en paramètre( provient du form); } }
Ensuite tu peux vider ta BD et réinsérer les utilisateurs.
De manière générale dans une vue twig, pour vérifier qu'un user a bien un rôle donné on utilise la méthode is_granted :
Code:

1 2 3 4 {% if is_granted('ROLE_USER') %} // faire quelque chose {% endif %}

18/06/2018, 12h45
armel18

ps: l'interface AdvancedUserInterface est deprecated, faudra la remplacer par

Code:

use Symfony\Component\Security\Core\User\UserInterface;