BCard - Documentation technique

AuthApiController extends AbstractController
in package

BCard

Contrôleur d'API d'authentification et de gestion du cycle de vie des comptes.

Il couvre l'inscription, la connexion par email et mot de passe avec émission d'un jeton JWT et d'un refresh token, la vérification d'adresse email par code à usage unique et son renvoi, le changement de mot de passe, la demande de réinitialisation, la consultation du profil connecté ainsi que le rafraîchissement et la révocation des refresh tokens. La connexion impose un email vérifié et un compte activé ; la création d'un compte déclenche l'attribution d'un abonnement gratuit.

Préfixe de route : /api/auth. La majorité des actions est publique ; seules /me, /change-password et /logout exigent une session authentifiée.

#[Route]: '/api/auth'; $name: 'api_auth_'

#[Tag]: $name: 'Authentification'; $description: 'Endpoints d\'authentification et de gestion des comptes'

Properties

$emailVerificationService : EmailVerificationService
$entityManager : EntityManagerInterface
$passwordHasher : UserPasswordHasherInterface
$subscriptionService : SubscriptionService
$validator : ValidatorInterface

Methods

__construct() : mixed
changePassword() : JsonResponse: Change le mot de passe de l'utilisateur authentifié.
forgotPassword() : JsonResponse: Déclenche l'envoi d'un lien de réinitialisation de mot de passe.
login() : JsonResponse: Authentifie un utilisateur et émet un couple de jetons.
logout() : JsonResponse: Termine la session côté client.
me() : JsonResponse: Retourne le profil de l'utilisateur authentifié et ses cartes de visite.
refreshToken() : JsonResponse: Émet un nouveau jeton d'accès à partir d'un refresh token valide.
register() : JsonResponse: Inscrit un nouvel utilisateur et déclenche la vérification d'email.
resendVerificationCode() : JsonResponse: Renvoie un nouveau code de vérification d'adresse e-mail.
revokeToken() : JsonResponse: Révoque un refresh token.
verifyEmail() : JsonResponse: Vérifie le code de confirmation d'adresse e-mail et connecte l'utilisateur.

$emailVerificationService read-only


        private
            EmailVerificationService
    $emailVerificationService

$entityManager read-only


        private
            EntityManagerInterface
    $entityManager

$passwordHasher read-only


        private
            UserPasswordHasherInterface
    $passwordHasher

$subscriptionService read-only


        private
            SubscriptionService
    $subscriptionService

$validator read-only


        private
            ValidatorInterface
    $validator

__construct()


    public
                    __construct(EntityManagerInterface $entityManager, UserPasswordHasherInterface $passwordHasher, ValidatorInterface $validator, SubscriptionService $subscriptionService, EmailVerificationService $emailVerificationService) : mixed

Parameters

$entityManager : EntityManagerInterface: Gestionnaire d'entités Doctrine, utilisé pour persister les comptes et les mots de passe.
$passwordHasher : UserPasswordHasherInterface: Service de hachage et de vérification des mots de passe.
$validator : ValidatorInterface: Validateur appliqué à l'entité User lors de l'inscription.
$subscriptionService : SubscriptionService: Service métier créant l'abonnement gratuit à l'inscription.
$emailVerificationService : EmailVerificationService: Service de génération, d'envoi et de contrôle des codes de vérification d'email.

changePassword()

Change le mot de passe de l'utilisateur authentifié.


    public
                    changePassword(Request $request) : JsonResponse

Exige les deux clés current_password et new_password, vérifie l'ancien mot de passe puis impose une longueur minimale de 6 caractères au nouveau (aucune autre règle de complexité n'est appliquée). Le nouveau mot de passe est haché et l'indicateur mustChangePassword est remis à false, ce qui lève l'obligation de changement imposée par exemple après une réinitialisation. Les refresh tokens existants ne sont pas révoqués.

Route : /api/auth/change-password (POST), nom api_auth_change_password. Requiert IS_AUTHENTICATED.

Corps attendu : {"current_password": "string — obligatoire", "new_password": "string — obligatoire, 6 caractères minimum"}

Réponses : 200 mot de passe modifié, 400 clé manquante, 400 mot de passe actuel incorrect, 400 nouveau mot de passe trop court, 401 requête non authentifiée.

Parameters

$request : Request: Requête HTTP dont le corps JSON porte les deux mots de passe.

#[IsGranted]: 'IS_AUTHENTICATED'

#[Post]: $path: '/api/auth/change-password'; $description: 'Permet à l\'utilisateur de changer son mot de passe'; $summary: 'Change le mot de passe de l\'utilisateur'; $security: [['bearerAuth' => []]]; $requestBody: new OA\RequestBody(required: true, content: new OA\JsonContent(required: ['current_password', 'new_password'], properties: [new OA\Property(property: 'current_password', type: 'string', example: 'ancien_mot_de_passe'), new OA\Property(property: 'new_password', type: 'string', example: 'nouveau_mot_de_passe')])); $tags: ['Authentification']; $responses: [new OA\Response(response: 200, description: 'Mot de passe changé avec succès', content: new OA\JsonContent(properties: [new OA\Property(property: 'message', type: 'string', example: 'Mot de passe changé avec succès')])), new OA\Response(response: 400, description: 'Mot de passe actuel incorrect ou nouveau mot de passe invalide'), new OA\Response(response: 401, description: 'Non authentifié')]

#[Route]: '/change-password'; $name: 'change_password'; $methods: ['POST']

Return values

JsonResponse —

Message de confirmation, ou message d'erreur sous la clé error.

forgotPassword()

Déclenche l'envoi d'un lien de réinitialisation de mot de passe.


    public
                    forgotPassword(Request $request, UserRepository $userRepository, MailerService $mailerService, EntityManagerInterface $entityManager) : JsonResponse

Si l'adresse correspond à un compte, un jeton aléatoire de 32 octets est généré, enregistré sur l'utilisateur et envoyé par e-mail. Toute exception survenue pendant cette phase est journalisée via error_log() puis absorbée.

La réponse est volontairement identique que le compte existe ou non, afin de ne pas permettre d'énumérer les adresses enregistrées.

Route : /api/auth/forgot-password (POST), nom api_auth_forgot_password. Accès public.

Corps attendu : {"email": "string — adresse du compte"}

Réponses : 200 dans tous les cas où l'e-mail est fourni ; 400 si email est absent ou vide.

Parameters

$request : Request: Requête portant le corps JSON.
$userRepository : UserRepository: Recherche du compte par adresse e-mail.
$mailerService : MailerService: Envoi de l'e-mail de réinitialisation.
$entityManager : EntityManagerInterface: Persistance du jeton de réinitialisation.

#[Post]: $path: '/api/auth/forgot-password'; $description: 'Envoie un email de réinitialisation de mot de passe'; $summary: 'Demande de réinitialisation de mot de passe'; $requestBody: new OA\RequestBody(required: true, content: new OA\JsonContent(required: ['email'], properties: [new OA\Property(property: 'email', type: 'string', format: 'email', example: 'user@example.com')])); $tags: ['Authentification']; $responses: [new OA\Response(response: 200, description: 'Email de réinitialisation envoyé', content: new OA\JsonContent(properties: [new OA\Property(property: 'message', type: 'string', example: 'Si cet email existe, un lien de réinitialisation a été envoyé')])), new OA\Response(response: 400, description: 'Email manquant ou invalide')]

#[Route]: '/forgot-password'; $name: 'forgot_password'; $methods: ['POST']

Return values

JsonResponse —

Message neutre, ou {"error": "..."} en cas d'e-mail manquant.

login()

Authentifie un utilisateur et émet un couple de jetons.


    public
                    login(Request $request, UserRepository $userRepository, JWTTokenManagerInterface $jwtManager, RefreshTokenService $refreshTokenService) : JsonResponse

Contrôle la présence des clés email et password, recherche le compte puis vérifie le mot de passe ; un compte inconnu et un mot de passe erroné produisent le même message générique. Si l'email n'est pas vérifié, la connexion est refusée avec un code 403 : un nouveau code de vérification est envoyé lorsque le délai d'anti-rejeu le permet, l'indicateur verification_sent distinguant les deux cas, et un échec d'envoi conduit également à une 403. Si le compte n'est pas activé, la connexion est refusée avec requires_activation. En cas de succès, un JWT est créé par le gestionnaire Lexik et un refresh token est généré et persisté.

Route : /api/auth/login (POST), nom api_auth_login. Accessible sans authentification.

Corps attendu : {"email": "string — obligatoire", "password": "string — obligatoire"}

Réponses : 200 connexion réussie ({token, refresh_token, user}), 400 email ou mot de passe manquant, 401 identifiants invalides, 403 email non vérifié (requires_verification, user_id, verification_sent), 403 compte non activé (requires_activation).

Parameters

$request : Request: Requête HTTP dont le corps JSON porte les identifiants.
$userRepository : UserRepository: Dépôt utilisé pour retrouver le compte par email.
$jwtManager : JWTTokenManagerInterface: Gestionnaire de création du jeton JWT.
$refreshTokenService : RefreshTokenService: Service de création du refresh token.

#[Post]: $path: '/api/auth/login'; $description: 'Authentifie un utilisateur et retourne un token JWT'; $summary: 'Connexion utilisateur'; $requestBody: new OA\RequestBody(required: true, content: new OA\JsonContent(required: ['email', 'password'], properties: [new OA\Property(property: 'email', type: 'string', format: 'email', example: 'user@example.com'), new OA\Property(property: 'password', type: 'string', example: 'password123')])); $tags: ['Authentification']; $responses: [new OA\Response(response: 200, description: 'Connexion réussie', content: new OA\JsonContent(properties: [new OA\Property(property: 'token', type: 'string', example: 'eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9...'), new OA\Property(property: 'refresh_token', type: 'string', example: 'def50200a1b2c3d4e5f6...'), new OA\Property(property: 'user', properties: [new OA\Property(property: 'id', type: 'integer', example: 1), new OA\Property(property: 'email', type: 'string', example: 'user@example.com'), new OA\Property(property: 'name', type: 'string', example: 'John Doe'), new OA\Property(property: 'roles', type: 'array', items: new OA\Items(type: 'ROLE_USER'))], type: 'object')])), new OA\Response(response: 401, description: 'Identifiants invalides'), new OA\Response(response: 400, description: 'Données manquantes')]

#[Route]: '/login'; $name: 'login'; $methods: ['POST']

Return values

JsonResponse —

Objet JSON {token, refresh_token, user: {id, email, name, roles}}, ou objet d'erreur.

logout()

Termine la session côté client.


    public
                    logout() : JsonResponse

L'authentification étant sans état, cette action ne réalise aucun traitement serveur : ni le JWT ni les refresh tokens ne sont invalidés. Elle sert de point d'entrée conventionnel, la suppression effective du jeton incombant au client. Pour invalider réellement un refresh token, utiliser AuthApiController::revokeToken().

Route : /api/auth/logout (POST), nom api_auth_logout. Requiert ROLE_USER.

Réponses : 200 systématiquement, 401 requête non authentifiée.

#[IsGranted]: 'ROLE_USER'

#[Post]: $path: '/api/auth/logout'; $description: 'Déconnecte l\'utilisateur (invalide le token côté client)'; $summary: 'Déconnexion'; $security: [['bearerAuth' => []]]; $tags: ['Authentification']; $responses: [new OA\Response(response: 200, description: 'Déconnexion réussie', content: new OA\JsonContent(properties: [new OA\Property(property: 'message', type: 'string', example: 'Déconnexion réussie')]))]

#[Route]: '/logout'; $name: 'logout'; $methods: ['POST']

Return values

JsonResponse —

Message de confirmation {"message": "Déconnexion réussie"}.

me()

Retourne le profil de l'utilisateur authentifié et ses cartes de visite.


    public
                    me() : JsonResponse

Parcourt l'ensemble des cartes de visite du compte, sans pagination, et met en forme pour chacune ses coordonnées, ses liens sociaux, ses fichiers (image, CV, QR code) et la liste de ses activités avec leurs brochures. La date de création des cartes est formatée en Y-m-d H:i:s. La charge utile réelle ne contient ni business ni company, contrairement au schéma OpenApi déclaré.

Voir aussi UserApiController::getProfile(), qui expose une vue plus réduite du même compte.

Route : /api/auth/me (GET), nom api_auth_me. Requiert IS_AUTHENTICATED.

Réponses : 200 profil renvoyé, 401 requête non authentifiée.

#[Get]: $path: '/api/auth/me'; $description: 'Récupère les informations de l\'utilisateur actuellement connecté avec ses cartes de visite'; $summary: 'Informations de l\'utilisateur connecté'; $security: [['bearerAuth' => []]]; $tags: ['Authentification']; $responses: [new OA\Response(response: 200, description: 'Informations de l\'utilisateur', content: new OA\JsonContent(properties: [new OA\Property(property: 'id', type: 'integer', example: 1), new OA\Property(property: 'email', type: 'string', example: 'user@example.com'), new OA\Property(property: 'name', type: 'string', example: 'Abdoulaye CAMARA'), new OA\Property(property: 'phone', type: 'string', example: '+33123456789'), new OA\Property(property: 'business', type: 'boolean', example: false), new OA\Property(property: 'isActivated', type: 'boolean', example: false), new OA\Property(property: 'profile', type: 'string', example: 'profile.png'), new OA\Property(property: 'company', type: 'string', example: 'Ma Société'), new OA\Property(property: 'roles', type: 'array', items: new OA\Items(type: 'string')), new OA\Property(property: 'business_cards', type: 'array', items: new OA\Items(type: 'object'))])), new OA\Response(response: 401, description: 'Non authentifié')]

#[IsGranted]: 'IS_AUTHENTICATED'

#[Route]: '/me'; $name: 'me'; $methods: ['GET']

Return values

JsonResponse —

Objet JSON {id, email, name, phone, isActivated, profile, roles, business_cards}.

refreshToken()

Émet un nouveau jeton d'accès à partir d'un refresh token valide.


    public
                    refreshToken(Request $request, RefreshTokenService $refreshTokenService, JWTTokenManagerInterface $jwtManager) : JsonResponse

Le refresh token est validé par RefreshTokenService::validateRefreshToken(), qui renvoie l'utilisateur associé. Un nouveau JWT et un nouveau refresh token sont alors émis (rotation) : le client doit remplacer les deux valeurs.

Route : /api/auth/token/refresh (POST), nom api_auth_token_refresh. Accès public.

Corps attendu : {"refresh_token": "string"}

Réponses : 200 jetons renouvelés ; 400 refresh_token absent ; 401 refresh token invalide, révoqué ou expiré.

Parameters

$request : Request: Requête portant le corps JSON.
$refreshTokenService : RefreshTokenService: Validation et émission des refresh tokens.
$jwtManager : JWTTokenManagerInterface: Émission du jeton d'accès JWT.

#[Post]: $path: '/api/auth/token/refresh'; $description: 'Génère un nouveau token JWT à partir d\'un refresh token valide'; $summary: 'Rafraîchir le token JWT'; $tags: ['Authentification']

#[RequestBody]: $required: true; $content: new OA\JsonContent(required: ['refresh_token'], properties: [new OA\Property(property: 'refresh_token', description: 'Le refresh token', type: 'string')], type: 'object')

#[Response]: $response: 200; $description: 'Token rafraîchi avec succès'; $content: new OA\JsonContent(properties: [new OA\Property(property: 'token', description: 'Le nouveau token JWT', type: 'string'), new OA\Property(property: 'refresh_token', description: 'Le nouveau refresh token', type: 'string')], type: 'object')

#[Response]: $response: 401; $description: 'Refresh token invalide ou expiré'; $content: new OA\JsonContent(properties: [new OA\Property(property: 'code', type: 'integer', example: 401), new OA\Property(property: 'message', type: 'string', example: 'Invalid refresh token')], type: 'object')

#[Route]: '/token/refresh'; $name: 'token_refresh'; $methods: ['POST']

Return values

JsonResponse —

{"token", "refresh_token"}, ou {"code", "message"} en cas d'échec.

register()

Inscrit un nouvel utilisateur et déclenche la vérification d'email.


    public
                    register(Request $request, UserRepository $userRepository) : JsonResponse

Le corps doit être un JSON décodable. L'email n'est rejeté comme déjà utilisé que si le compte existant est déjà vérifié : un compte homonyme non vérifié n'empêche pas une nouvelle inscription. Le nom affiché est composé par concaténation de firstname et lastname. Les rôles transmis sont repris tels quels, sans liste blanche, avec repli sur ROLE_USER s'ils sont absents ou vides. Le mot de passe est obligatoire et haché avant validation de l'entité. Après persistance, un abonnement gratuit est créé via SubscriptionService::createFreeSubscriptionForUser(), puis le code de vérification est envoyé ; un échec d'envoi est seulement journalisé et l'inscription reste un succès, la réponse annonçant néanmoins verification_sent à true.

Route : /api/auth/register (POST), nom api_auth_register. Accessible sans authentification.

Corps attendu : {"email": "string — obligatoire", "password": "string — obligatoire", "firstname": "string — utilisé pour composer le nom", "lastname": "string — utilisé pour composer le nom", "phone": "string — optionnel", "roles": "list<string> — optionnel, défaut ROLE_USER"}

Réponses : 201 compte créé ({message, user, verification_sent}), 400 corps JSON illisible, 400 email déjà utilisé par un compte vérifié, 400 mot de passe manquant, 400 violations de contraintes ({error, violations}).

Parameters

$request : Request: Requête HTTP dont le corps JSON décrit le compte à créer.
$userRepository : UserRepository: Dépôt utilisé pour contrôler l'existence de l'email.

#[Post]: $path: '/api/auth/register'; $description: 'Crée un nouveau compte utilisateur'; $summary: 'Inscription d\'un nouvel utilisateur'; $requestBody: new OA\RequestBody(required: true, content: new OA\JsonContent(required: ['email', 'password', 'firstname', 'lastname', 'roles'], properties: [new OA\Property(property: 'email', type: 'string', format: 'email', example: 'user@example.com'), new OA\Property(property: 'password', type: 'string', minLength: 6, example: 'password123'), new OA\Property(property: 'firstname', type: 'string', example: 'John'), new OA\Property(property: 'lastname', type: 'string', example: 'Doe'), new OA\Property(property: 'phone', type: 'string', example: '+33123456789'), new OA\Property(property: 'roles', type: 'array', items: new OA\Items(type: 'ROLE_USER'))])); $tags: ['Authentification']; $responses: [new OA\Response(response: 201, description: 'Utilisateur créé avec succès', content: new OA\JsonContent(properties: [new OA\Property(property: 'message', type: 'string', example: 'Utilisateur créé avec succès'), new OA\Property(property: 'user', properties: [new OA\Property(property: 'id', type: 'integer', example: 1), new OA\Property(property: 'email', type: 'string', example: 'user@example.com'), new OA\Property(property: 'firstname', type: 'string', example: 'John'), new OA\Property(property: 'lastname', type: 'string', example: 'Doe'), new OA\Property(property: 'business', type: 'boolean', example: false)], type: 'object')])), new OA\Response(response: 400, description: 'Données invalides ou email déjà utilisé', content: new OA\JsonContent(properties: [new OA\Property(property: 'error', type: 'string', example: 'Cet email est déjà utilisé'), new OA\Property(property: 'violations', type: 'array', items: new OA\Items(type: 'string'))]))]

#[Route]: '/register'; $name: 'register'; $methods: ['POST']

Return values

JsonResponse —

Message de confirmation et sous-objet user (id, email, name), ou erreurs.

resendVerificationCode()

Renvoie un nouveau code de vérification d'adresse e-mail.


    public
                    resendVerificationCode(Request $request, UserRepository $userRepository) : JsonResponse

L'envoi est refusé si le compte est déjà vérifié, ou si le délai d'anti-rejeu imposé par EmailVerificationService::canResendCode() n'est pas écoulé. Un échec d'envoi est converti en réponse 500 plutôt que propagé.

Route : /api/auth/resend-verification-code (POST), nom api_auth_resend_verification_code. Accès public.

Corps attendu : {"user_id": "int — identifiant du compte"}

Réponses : 200 code renvoyé ; 400 user_id absent, compte déjà vérifié ou renvoi trop rapproché ; 404 utilisateur introuvable ; 500 échec de l'envoi.

Parameters

$request : Request: Requête portant le corps JSON.
$userRepository : UserRepository: Recherche du compte par identifiant.

#[Post]: $path: '/api/auth/resend-verification-code'; $description: 'Renvoie un nouveau code de vérification d\'email'; $summary: 'Renvoyer le code OTP de vérification'; $requestBody: new OA\RequestBody(required: true, content: new OA\JsonContent(required: ['user_id'], properties: [new OA\Property(property: 'user_id', type: 'integer', example: 1)])); $tags: ['Authentification']; $responses: [new OA\Response(response: 200, description: 'Code de vérification renvoyé avec succès', content: new OA\JsonContent(properties: [new OA\Property(property: 'message', type: 'string', example: 'Un nouveau code de vérification a été envoyé'), new OA\Property(property: 'success', type: 'boolean', example: true)])), new OA\Response(response: 400, description: 'Impossible de renvoyer le code (trop récent ou utilisateur déjà vérifié)'), new OA\Response(response: 404, description: 'Utilisateur non trouvé')]

#[Route]: '/resend-verification-code'; $name: 'resend_verification_code'; $methods: ['POST']

Return values

JsonResponse —

{"message", "success"} en cas de succès, {"error", "success"} sinon.

revokeToken()

Révoque un refresh token.


    public
                    revokeToken(Request $request, RefreshTokenService $refreshTokenService) : JsonResponse

La révocation est déléguée à RefreshTokenService::revokeRefreshToken(). Qu'un jeton correspondant ait été trouvé ou non, la réponse est un statut 200 : seul le libellé du message diffère (« Token revoked successfully » ou « Token not found »), ce qui évite de renseigner un appelant sur l'existence d'un jeton donné.

Route : /api/auth/token/revoke (POST), nom api_auth_token_revoke. Accès public.

Corps attendu : {"refresh_token": "string — jeton à révoquer"}

Réponses : 200 dans tous les cas où le jeton est fourni ; 400 si refresh_token est absent du corps.

Parameters

$request : Request: Requête portant le corps JSON.
$refreshTokenService : RefreshTokenService: Révocation du refresh token.

#[Post]: $path: '/api/auth/token/revoke'; $description: 'Révoque un refresh token spécifique'; $summary: 'Révoquer un refresh token'; $tags: ['Authentification']

#[RequestBody]: $required: true; $content: new OA\JsonContent(required: ['refresh_token'], properties: [new OA\Property(property: 'refresh_token', description: 'Le refresh token à révoquer', type: 'string')], type: 'object')

#[Response]: $response: 200; $description: 'Token révoqué avec succès'; $content: new OA\JsonContent(properties: [new OA\Property(property: 'message', type: 'string', example: 'Token revoked successfully')], type: 'object')

#[Route]: '/token/revoke'; $name: 'token_revoke'; $methods: ['POST']

Return values

JsonResponse —

{"message": "..."}, ou {"code": 400, "message": "Missing refresh token"}.

verifyEmail()

Vérifie le code de confirmation d'adresse e-mail et connecte l'utilisateur.


    public
                    verifyEmail(Request $request, UserRepository $userRepository, JWTTokenManagerInterface $jwtManager, RefreshTokenService $refreshTokenService) : JsonResponse

Le code est validé par EmailVerificationService::verifyCode(). En cas de succès, un jeton JWT et un refresh token sont émis dans la foulée : l'utilisateur est donc authentifié sans avoir à repasser par /api/auth/login.

Route : /api/auth/verify-email (POST), nom api_auth_verify_email. Accès public.

Corps attendu : {"user_id": "int — identifiant du compte", "verification_code": "string — code reçu par e-mail"}

Réponses : 200 code valide (jetons émis) ; 400 corps incomplet ou code invalide ou expiré ; 404 utilisateur introuvable.

Parameters

$request : Request: Requête portant le corps JSON.
$userRepository : UserRepository: Recherche du compte par identifiant.
$jwtManager : JWTTokenManagerInterface: Émission du jeton d'accès JWT.
$refreshTokenService : RefreshTokenService: Émission du refresh token.

#[Post]: $path: '/api/auth/verify-email'; $description: 'Vérifie le code de vérification d\'email et connecte l\'utilisateur'; $summary: 'Vérification d\'email avec code'; $requestBody: new OA\RequestBody(required: true, content: new OA\JsonContent(required: ['user_id', 'verification_code'], properties: [new OA\Property(property: 'user_id', type: 'integer', example: 1), new OA\Property(property: 'verification_code', type: 'string', example: '123456')])); $tags: ['Authentification']; $responses: [new OA\Response(response: 200, description: 'Email vérifié avec succès, utilisateur connecté', content: new OA\JsonContent(properties: [new OA\Property(property: 'message', type: 'string', example: 'Email vérifié avec succès'), new OA\Property(property: 'token', type: 'string', example: 'eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9...'), new OA\Property(property: 'refresh_token', type: 'string', example: 'def50200a1b2c3d4e5f6...'), new OA\Property(property: 'user', properties: [new OA\Property(property: 'id', type: 'integer', example: 1), new OA\Property(property: 'email', type: 'string', example: 'user@example.com'), new OA\Property(property: 'name', type: 'string', example: 'John Doe'), new OA\Property(property: 'roles', type: 'array', items: new OA\Items(type: 'ROLE_USER'))], type: 'object')])), new OA\Response(response: 400, description: 'Code de vérification invalide ou expiré'), new OA\Response(response: 404, description: 'Utilisateur non trouvé')]

#[Route]: '/verify-email'; $name: 'verify_email'; $methods: ['POST']

Return values

JsonResponse —

{"message", "token", "refresh_token", "user": {"id", "email", "name", "roles"}}, ou {"error": "..."} avec le statut correspondant.

AuthApiController extends AbstractController in package BCard

Attributes

Table of Contents

Properties

Methods

Properties

$emailVerificationService read-only

$entityManager read-only

$passwordHasher read-only

$subscriptionService read-only

$validator read-only

Methods

__construct()

Parameters

changePassword()

Parameters

Attributes

Return values

forgotPassword()

Parameters

Attributes

Return values

login()

Parameters

Attributes

Return values

logout()

Attributes

Return values

me()

Attributes

Return values

refreshToken()

Parameters

Attributes

Return values

register()

Parameters

Attributes

Return values

resendVerificationCode()

Parameters

Attributes

Return values

revokeToken()

Parameters

Attributes

Return values

verifyEmail()

Parameters

Attributes

Return values

AuthApiController extends AbstractController
in package

BCard