Discussion :

[Nicolas Legrand]

Bonjour ! je viens vers vous car je bloque sur la vérification de la valeur d'un attribut lors de la soumission de mon formulaire de connexion.

Je souhaiterai lors de la validation de mon formulaire de connexion vérifier si mon champs token en base de donnée est null (vide) ou si il comporte bien un chaîne de caractère.

Lors de la création d'un compte utilisateur j'envoie à l'utilisateur un mail pour qu'il confirme l'inscription, si il clique sur le lien, le token en base de données devient null,
ce qui me permettrai de vérifier si le compte a été activé ou non à condition que je puisse en vérifier la valeur du champs à la connexion de l'utilisateur.

Malheureusement je ne parviens pas à comprendre comment faire. J'arrive à récupérer les infos de mon objet que si l'utilisateur est connecté (via dump()) sinon j'obtient l'erreur suivante "call to a getActivationToken() on null" et je ne suis
pas certaine que ma condition soit correct. Si jamais vous pouvez m'aiguiller ou peut être me conseiller une autre façon de faire je suis preneur , merci d'avance sinon bonne journée et bon week end !!!

Ma méthode se nomme public function login ligne 79
Voici mon UserController.php

Code PHP :

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
 
<?php
 
namespace App\Controller;
 
use App\Entity\User;
use App\Form\RegisterType;
use App\Repository\UserRepository;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bridge\Twig\Mime\TemplatedEmail;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Mailer\MailerInterface;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Security\Http\Authentication\AuthenticationUtils;
use Symfony\Component\Security\Core\Encoder\UserPasswordEncoderInterface;
 
class UserController extends AbstractController
{
    /**
     * @Route("/inscription", name="register")
     */
    public function register(Request $request, EntityManagerInterface $em, UserPasswordEncoderInterface $encoder,MailerInterface $mailer )
    {
        $user = new User();
        $form = $this->createForm(RegisterType::class,$user);
        $form->handleRequest($request);
 
        if($form->isSubmitted() && $form->isValid()){
            $passwordCrypte = $encoder->encodePassword($user, $user->getPassword());
            $user->setPassword($passwordCrypte);
            $user->setRoles("ROLE_USER");
            $user->setActivationtoken(md5(uniqid()));
            $em->persist($user);
            $em->flush();
 
            $messageactivation = (new TemplatedEmail())
            ->from('struggler@gmail.com')
            ->to($user->getEmail())
            // ->htmlTemplate('emails/activation.html.twig', ['token' => $user->getActivationtoken()])
            ->htmlTemplate('emails/activation.html.twig')
            ->context(['token' => $user->getActivationtoken()])
            ->subject('Activation du compte utilisateur');
 
        // on envoit
        $mailer->send($messageactivation);
            $this->addFlash("success", "Votre vompte a été crée un mail vient de vous êtres envoyé");
            return $this->redirectToRoute("register");    
        }    
 
        return $this->render('user/register.html.twig',[
            'form' => $form->createView()
        ]);
    }
 
    /**
     * @Route("/activation/{token}", name="activation")
     */
    public function activation($token,UserRepository $usersRepo, EntityManagerInterface $em)
    {
        $user = $usersRepo->findOneBy(['activationtoken' => $token]);
        //si le token n'existe pas alors l'utilisateur non plus
        if(!$user){
            throw $this->createNotFoundException('Cet utilisateur n\'existe pas');
        }
        $user->setActivationtoken(null);
        $em->persist($user);
        $em->flush();
 
        $this->addFlash('mess', 'Votre compte vient d\'être activé');
 
        return $this->redirectToRoute('login');
    }
 
 
     /**
     * @Route("/connexion", name="login")
     */
    public function login(AuthenticationUtils $util)
    {  
 
    $user = $this->getUser(); 
 
     $veriftoken = ($user->getActivationToken());
     dump($veriftoken);
    //    if(veriftoken !== null) {
    //     $this->addFlash('message_error', 'Votre compte n'est pas activé');
    //   } 
        return $this->render('user/login.html.twig',[
             "lastUserName" => $util->getLastUsername(),
             "error" => $util->getLastAuthenticationError()
        ]);
    }
 
     /**
     * @Route("/deconnexion", name="logout")
     */
    public function logout()
    {
 
    }
 
     /**
     * @Route("/moncompte", name="account")
     */
    public function account()
    {
        return $this->render('user/account.html.twig');
    }
}

Voici ma class User.php

Code PHP :

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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
<?php
 
namespace App\Entity;
 
use App\Repository\UserRepository;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
 
/**
 * @ORM\Entity(repositoryClass=UserRepository::class)
 * @UniqueEntity(
 * fields = {"username"},
 * message ="Pseudo ou email déjà utilisé"
 * )
 * @UniqueEntity(
 * fields = {"email"},
 * message ="Pseudo ou email déjà utilisé"
 * )
 */
class User implements UserInterface
{
    /**
     * @ORM\Id
     * @ORM\GeneratedValue
     * @ORM\Column(type="integer")
     */
    private $id;
 
    /**
     * @ORM\Column(type="string", length=255)
     * @Assert\Length(min=4, minMessage="Votre pseudo doit comporter au moins 5 caractères")
     * @Assert\NotBlank(message="Vous devez remplir ce champs")
     */
    private $username;
 
    /**
     * @ORM\Column(type="string", length=255)
     * @Assert\NotBlank(message="Vous devez remplir ce champs")
     * @Assert\Length(min=4, minMessage="Votre pseudo doit comporter au moins 5 caractères")
     */
    private $password;
 
    /**
     * @ORM\Column(type="string", length=255)
     * @Assert\Regex("/^[a-z0-9-_.]+@[a-z0-9-_.]+\.[a-z]{2,3}$/i")
     * @Assert\NotBlank(message="Vous devez remplir ce champs")
     */
    private $email;
 
    /**
     * @ORM\Column(type="string", length=255)
     */
    private $roles;
 
    /**
     * @ORM\Column(type="string", length=50, nullable=true)
     */
    private $activationtoken;
 
    public function getId(): ?int
    {
        return $this->id;
    }
 
    public function getUsername(): ?string
    {
        return $this->username;
    }
 
    public function setUsername(string $username): self
    {
        $this->username = $username;
 
        return $this;
    }
 
    public function getPassword(): ?string
    {
        return $this->password;
    }
 
    public function setPassword(string $password): self
    {
        $this->password = $password;
 
        return $this;
    }
 
    public function getEmail(): ?string
    {
        return $this->email;
    }
 
    public function setEmail(string $email): self
    {
        $this->email = $email;
 
        return $this;
    }
 
    public function getRoles()
    {
        return [$this->roles];
    }
 
    public function setRoles(string $roles): self
    {
        $this->roles = $roles;
 
        return $this;
    }
 
    public function getActivationtoken(): ?string
    {
        return $this->activationtoken;
    }
 
    public function setActivationtoken(?string $activationtoken): self
    {
        $this->activationtoken = $activationtoken;
 
        return $this;
    }
 
    public function eraseCredentials(){
 
    }
 
    public function getSalt(){
 
    }
}

[_Thomas]

Salut,

Donc si je comprends bien, tu voudrais qu'un utilisateur qui arrive sur /login ne puisse s'authentifier que s'il saisit un couple username/password valide ET que son compte est actif (càd que la propriété token du User concerné vaut null) ?

À mon avis tu devrais creuser la documentation de la partie Security, en particulier la notion de Guard Authenticator (https://symfony.com/doc/current/secu...ntication.html).
Si tu galères au début, tu peux aussi regarder ce tuto : https://symfonycasts.com/screencast/symfony-security (les vidéos sont payantes mais le script et les extraits de code sont librement accessibles au dessous du lecteur)

Et si besoin, n'hésite pas à revenir ici poser tes questions !

[Nicolas Legrand]

Salut,

Oui exactement, quand l'utilisateur s'inscrit, un token en bdd se créé et il reçoit un mail dans sa boîte avec le message "veuillez cliquez sur le lien pour confirmer votre compte".
Si il clique sur le lien le token en base de donnée devient alors null. Je voudrai vérifier que quand un utilisateur se connecter le token en base de donnée est bien === à null.

Mon problème c'est que je sais pas comment faire, vu que je ne peux pas utiliser de champs de formulaire pour vérifier cette info. Je suis un peu dans le néant après avoir passé quelques jours à chercher une solution.
Je vais regarder la doc comme tu m'as dit, il n'y a aucun vidéo par contre mais pas bien grave ^^

[_Thomas]

Je vais regarder la doc comme tu m'as dit, il n'y a aucun vidéo par contre mais pas bien grave ^^

J'ai modifié mon précédent message pour mettre le bon lien vers le tuto SymfonyCasts, my bad !

Mon problème c'est que je sais pas comment faire, vu que je ne peux pas utiliser de champs de formulaire pour vérifier cette info.

Ne t'en fais pas, quand tu auras une idée plus précise du fonctionnement des Guard Authenticators, tu comprendras comment définir ton propre processus d'authentification implémenter ta logique spécique.
À mon avis commence par lire cette page de la doc pour comprendre le principe général : https://symfony.com/doc/current/secu...ntication.html
Et ensuite si besoin tu peux lire le script de ce chapitre qui détaille et explique bien le rôle de chaque méthode d'un Guard : https://symfonycasts.com/screencast/...-authenticator

Bon courage !