src/Controller/RegistrationController.php line 65

  1. <?php
  3. namespace App\Controller;
  5. use App\Exceptions\RecaptchaException;
  6. use App\Exceptions\ValidationException;
  7. use App\Model\Registration\ProofForm;
  8. use App\Model\Registration\RegistrationForm;
  9. use App\Model\Registration\SubscriptionSignatureForm;
  10. use App\Services\Bank\BeneficiaryService;
  11. use App\Services\RecaptchaService;
  12. use App\Services\RegistrationService;
  13. use App\Services\TokenVerifier;
  14. use App\Services\User\AuthUserService;
  15. use Exception;
  16. use Symfony\Component\HttpFoundation\JsonResponse;
  17. use Symfony\Component\HttpFoundation\Request;
  18. use Symfony\Component\HttpFoundation\Response;
  19. use Symfony\Component\Routing\Annotation\Route;
  20. use Symfony\Component\Serializer\Exception\ExceptionInterface;
  21. use Symfony\Component\Serializer\SerializerInterface;
  22. use Symfony\Component\Validator\Validation;
  23. use Symfony\Contracts\HttpClient\Exception\ClientExceptionInterface;
  24. use Symfony\Contracts\HttpClient\Exception\RedirectionExceptionInterface;
  25. use Symfony\Contracts\HttpClient\Exception\ServerExceptionInterface;
  26. use Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface;
  27. use Symfony\Contracts\HttpClient\HttpClientInterface;
  28. use Symfony\Contracts\Translation\TranslatorInterface;
  29. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  30. use Karser\Recaptcha3Bundle\Validator\Constraints\Recaptcha3Validator;
  32. class RegistrationController extends AbstractController
  33. {
  34.     const REG_TOKEN_SESSION_KEY = 'REGISTRATION_TOKEN';
  35.     const REG_USER_ID_SESSION_KEY = 'REGISTRATION_USER_ID';
  36.     const REG_REQUEST_ID_SESSION_KEY = 'REGISTRATION_REQUEST_ID';
  37.     const REG_REQUEST_COMPLETED_SESSION_KEY = 'REGISTRATION_REQUEST_COMPLETED';
  39.     protected RegistrationService $registrationService;
  40.     protected BeneficiaryService $beneficiaryService;
  41.     private AuthUserService $authUserServive;
  42.     private TokenVerifier $tokenVerifier;
  43.     protected $recaptcha3Validator;
  44.     protected $httpClient;
  45.     protected $translator;
  47.     public function __construct(RegistrationService $registrationService, Recaptcha3Validator $recaptcha3Validator, AuthUserService $authUserServive,
  48.                                 HttpClientInterface $httpClient, TranslatorInterface $translator, BeneficiaryService $beneficiaryService,
  49.                                 TokenVerifier $tokenVerifier)
  50.     {
  51.         $this->translator = $translator;
  52.         $this->registrationService = $registrationService;
  53.         $this->recaptcha3Validator = $recaptcha3Validator;
  54.         $this->httpClient = $httpClient;
  55.         $this->beneficiaryService = $beneficiaryService;
  56.         $this->authUserServive = $authUserServive;
  57.         $this->tokenVerifier = $tokenVerifier;
  58.     }
  60.     #[Route('/register', name: 'app_register')]
  61.     public function register(Request $request): Response
  62.     {
  63.         $user_id = $request->getSession()->get(self::REG_USER_ID_SESSION_KEY);
  64.         $request_id = $request->getSession()->get(self::REG_REQUEST_COMPLETED_SESSION_KEY);
  65.         $completed = $request->getSession()->get(self::REG_REQUEST_COMPLETED_SESSION_KEY, false);
  66.         $beneficiary_token = $request->get('token');
  68.         $beneficiary = null;
  69.         if (!empty($beneficiary_token)) {
  70.             $beneficiary = $this->beneficiaryService->getBeneficiaryByToken($beneficiary_token);
  72.             if ($beneficiary->client !== null) {
  73.                 $this->addFlash('danger', 'Vous disposez déjà d\'un compte. Connectez-vous pour gérer votre invitation.');
  74.                 return $this->redirectToRoute('app_login');
  75.             }
  76.         }
  78.         if ($completed && $user_id !== null && $request_id !== null) {
  79.             return $this->redirectToRoute('app_registration_success');
  80.         }
  82.         return $this->render('security/registration/index.html.twig', [
  83.             'beneficiary' => $beneficiary,
  84.         ]);
  85.     }
  87.     #[Route('/registration/save', name: 'app_registration_save', methods: ['GET', 'POST'])]
  88.     public function save(Request $request, SerializerInterface $serializer, RecaptchaService $recaptchaService): Response
  89.     {
  90.         try {
  91.             $input = $serializer->deserialize($request->getContent(), RegistrationForm::class, 'json');
  93.             try {
  94.                 $recaptchaService->verify($input->captchaToken, 'registration');
  95.             } catch (RecaptchaException $exception) {
  96.                 return new JsonResponse([
  97.                     'message' => $exception->getFormattedMessages(),
  98.                 ], 500);
  99.             }
  101.             $validator = Validation::createValidatorBuilder()
  102.                 ->enableAnnotationMapping()
  103.                 ->getValidator()
  104.             ;
  106.             $form_errors = $validator->validate($input, null, $input->getGroupSequence());
  107.             if (count($form_errors) > 0) {
  108.                 $errors = [];
  109.                 foreach ($form_errors as $error) {
  110.                     $errors[] = [
  111.                         'message' => $this->translator->trans($error->getMessageTemplate(), $error->getParameters(), 'validators'),
  112.                         'property' => $error->getPropertyPath(),
  113.                     ];
  114.                 }
  116.                 return new JsonResponse([
  117.                     'message' => $this->translator->trans('form.errors.invalid', [], 'account'),
  118.                     'errors' => $errors,
  119.                 ], 400);
  120.             }
  122.             $isNew = true;
  123.             if (!$request->getSession()->has(self::REG_USER_ID_SESSION_KEY)) {
  124.                 $user = $this->registrationService->postRegistration($input);
  126.                 if ($user === null) {
  127.                     throw new Exception('Problème technique lors de la création de votre compte.');
  128.                 }
  130.                 $request->getSession()->set(self::REG_USER_ID_SESSION_KEY, $user->id);
  131.                 $request->getSession()->set(self::REG_REQUEST_ID_SESSION_KEY, $user->requestId);
  132.                 $request->getSession()->set(self::REG_TOKEN_SESSION_KEY, $user->accessToken);
  133.             } else {
  134.                 $isNew = false;
  135.             }
  137.             return new JsonResponse([
  138.                 'success' => true,
  139.                 'message' => $this->translator->trans('form.success.'.($isNew ? 'create':'update'), [], 'account'),
  140.             ]);
  141.         } catch (ValidationException $exception) {
  142.             return new JsonResponse([
  143.                 'message' => $exception->getMessage(),
  144.                 'errors' => $exception->getErrors(),
  145.             ], 400);
  146.         } catch (Exception $exception) {
  147.             return new JsonResponse([
  148.                 'message' => $exception->getMessage()
  149.             ], Response::HTTP_INTERNAL_SERVER_ERROR);
  150.         }
  151.     }
  153.     #[Route('/registration/proofs/save', name: 'app_registration_save_proofs', methods: ['POST'])]
  154.     public function saveProofs(Request $request, SerializerInterface $serializer): Response
  155.     {
  156.         try {
  157.             /** @var ProofForm $input */
  158.             $input = $serializer->deserialize($request->getContent(), ProofForm::class, 'json');
  160.             if (empty($input->userId)) {
  161.                 $input->userId = (int)($request->getSession()->get(self::REG_USER_ID_SESSION_KEY, 0));
  162.             }
  164.             $validator = Validation::createValidatorBuilder()
  165.                 ->enableAnnotationMapping()
  166.                 ->getValidator()
  167.             ;
  169.             $form_errors = $validator->validate($input, null, $input->getGroupSequence());
  170.             if (count($form_errors) > 0) {
  171.                 $errors = [];
  172.                 foreach ($form_errors as $error) {
  173.                     $errors[] = [
  174.                         'message' => $this->translator->trans($error->getMessageTemplate(), $error->getParameters(), 'validators'),
  175.                         'property' => $error->getPropertyPath(),
  176.                     ];
  177.                 }
  179.                 return new JsonResponse([
  180.                     'message' => $this->translator->trans('form.errors.invalid', [], 'account'),
  181.                     'errors' => $errors,
  182.                 ], 400);
  183.             }
  185.             $this->registrationService->saveProof($input);
  187.             if (!empty($input->userId) && $this->tokenVerifier->isTokenValid()) {
  188.                 $this->authUserServive->getAllAboutMe(true);
  189.             }
  191.             return new JsonResponse([
  192.                 'success' => true,
  193.                 'message' => $this->translator->trans('form.success.proof', [], 'account'),
  194.             ]);
  195.         } catch (ValidationException $exception) {
  196.             return new JsonResponse([
  197.                 'message' => $exception->getMessage(),
  198.                 'errors' => $exception->getErrors(),
  199.             ], 400);
  200.         } catch (Exception $exception) {
  201.             return new JsonResponse([
  202.                 'message' => $exception->getMessage()
  203.             ], Response::HTTP_INTERNAL_SERVER_ERROR);
  204.         }
  205.     }
  207.     #[Route('/registration/generate/subscription', name: 'app_registration_generate_subscription', methods: ['POST'])]
  208.     public function generateSubscription(Request $request): Response
  209.     {
  210.         $content = $this->registrationService->generateSubscription(json_decode($request->getContent(), true));
  212.         if ($content === null) {
  213.             return new JsonResponse([
  214.                 'success' => false,
  215.                 'message' => 'Suite à une erreur technique, nous ne sommes pas dans la mesure de générer votre bulletin de souscription. Contactez l\'assistance',
  216.             ]);
  217.         }
  219.         return new Response(base64_encode($content), 200, [
  220.             'Cache-Control' => 'private',
  221.         ]);
  222.     }
  224.     /**
  225.      * @param Request $request
  226.      * @param SerializerInterface $serializer
  227.      * @return Response
  228.      * @throws ExceptionInterface
  229.      * @throws ClientExceptionInterface
  230.      * @throws RedirectionExceptionInterface
  231.      * @throws ServerExceptionInterface
  232.      * @throws TransportExceptionInterface
  233.      */
  234.     #[Route('/registration/subscription/signature', name: 'app_registration_subscription_signature', methods: ['POST'])]
  235.     public function postSubscriptionSignature(Request $request, SerializerInterface $serializer): Response
  236.     {
  237.         try {
  238.             /** @var SubscriptionSignatureForm $input */
  239.             $input = $serializer->deserialize($request->getContent(), SubscriptionSignatureForm::class, 'json');
  241.             if (empty($input->userId)) {
  242.                 $input->userId = (int) ($request->getSession()->get(self::REG_USER_ID_SESSION_KEY, 0));
  243.             }
  245.             $validator = Validation::createValidatorBuilder()
  246.                 ->enableAnnotationMapping()
  247.                 ->getValidator()
  248.             ;
  250.             $form_errors = $validator->validate($input, null, $input->getGroupSequence());
  251.             if (count($form_errors) > 0) {
  252.                 $errors = [];
  253.                 foreach ($form_errors as $error) {
  254.                     $errors[] = [
  255.                         'message' => $this->translator->trans($error->getMessageTemplate(), $error->getParameters(), 'validators'),
  256.                         'property' => $error->getPropertyPath(),
  257.                     ];
  258.                 }
  260.                 return new JsonResponse([
  261.                     'message' => $this->translator->trans('form.errors.invalid', [], 'account'),
  262.                     'errors' => $errors,
  263.                 ], 400);
  264.             }
  266.             $this->registrationService->saveSubscriptionSignature($input);
  268.             $request->getSession()->set(self::REG_REQUEST_COMPLETED_SESSION_KEY, true);
  270.             if (!empty($input->userId) && $this->tokenVerifier->isTokenValid()) {
  271.                 $this->authUserServive->getAllAboutMe(true);
  272.             }
  274.             return new JsonResponse([
  275.                 'success' => true,
  276.                 'message' => $this->translator->trans('form.success.signature', [], 'account'),
  277.             ]);
  278.         } catch (ValidationException $exception) {
  279.             return new JsonResponse([
  280.                 'message' => $exception->getMessage(),
  281.                 'errors' => $exception->getErrors(),
  282.             ], 400);
  283.         } catch (Exception $exception) {
  284.             return new JsonResponse([
  285.                 'message' => $exception->getMessage()
  286.             ], Response::HTTP_INTERNAL_SERVER_ERROR);
  287.         }
  288.     }
  290.     #[Route('/subscription/success', name: 'app_registration_success', methods: ['GET'])]
  291.     public function subscriptionSuccess(Request $request)
  292.     {
  293.         $user_id = $request->getSession()->get(self::REG_USER_ID_SESSION_KEY);
  294.         $request_id = $request->getSession()->get(self::REG_REQUEST_ID_SESSION_KEY);
  295.         $access_token = $request->getSession()->get(self::REG_TOKEN_SESSION_KEY);
  296.         $completed = $request->getSession()->get(self::REG_REQUEST_COMPLETED_SESSION_KEY, false);
  298.         if (!$completed || $user_id === null || $request_id === null) {
  299.             return $this->redirectToRoute('app_register');
  300.         }
  302.         $request->getSession()->remove(self::REG_TOKEN_SESSION_KEY);
  303.         $request->getSession()->remove(self::REG_USER_ID_SESSION_KEY);
  304.         $request->getSession()->remove(self::REG_REQUEST_ID_SESSION_KEY);
  305.         $request->getSession()->remove(self::REG_REQUEST_COMPLETED_SESSION_KEY);
  307.         return $this->render('security/registration/success.html.twig');
  308.     }
  310.     // region RESET PASSWORD
  311.     #[Route('/reset_request', name: 'app_reset_request')]
  312.     public function resetRequest(Request $request): Response
  313.     {
  315.         // Soumission du formulaire et validation
  316.         if ($request->isMethod('POST')) {
  318.             $email = $request->request->get('email');
  319.             try {
  320.                 $response = $this->registrationService->resetPassword($email);
  321.                 $statusCode = $response->getStatusCode();
  322.                 if ($statusCode === 200 || $statusCode === 201) {
  324.                     $this->addFlash('success', "Le mail a été envoyé avec succès, vérifiez votre adresse électronique.");
  325.                     return  $this->redirectToRoute('app_reset_check_password');
  326.                 } else {
  327.                     $this->addFlash('danger', "une erreur a été générée, veuillez vérifier votre adresse e-mail");
  328.                     return  $this->redirectToRoute('app_reset_request');
  329.                 }
  331.             } catch (Exception $e) {
  332.                 // Si la connexion échoue, affiche un message d'erreur à l'utilisateur
  333.                 $responseBody = json_decode($e->getMessage());
  334.                 $this->addFlash('danger', $responseBody);
  335.             }
  336.         }
  337.         //redirection et envoie de la vue
  338.         return $this->render('security/reset_password/request.html.twig', [
  339.         ]);
  340.     }
  342.     #[Route('/check_password_reset', name: 'app_reset_check_password')]
  343.     public function checkPassword(Request $request): Response
  344.     {
  345.         
  346.         // Soumission du formulaire et validation
  347.         if ($request->isMethod('POST')) {
  349.             $phone = $request->request->get('phone');
  350.             $email = $request->request->get('email');
  351.             $code = $request->request->get('code');
  352.             try {
  353.                 $response = $this->registrationService->checkResetPassword([
  354.                     'phone' => $phone,
  355.                     'email' => $email,
  356.                     'code' => $code
  357.                 ]);
  359.                 $content = json_decode($response->getContent(), true);
  360.                 $statusCode = $response->getStatusCode();
  361.                 if ($statusCode === 200 || $statusCode === 201) {
  363.                     $this->addFlash('success', "Le mail a été envoyé avec succès, vérifiez votre adresse électronique.");
  364.                     return  $this->redirectToRoute('app_reset_password_token',[
  365.                         'token' => $content['token']
  366.                     ]);
  367.                 } else {
  368.                     $this->addFlash('danger', "");
  369.                 }
  371.             } catch (Exception $e) {
  372.                 // Si la connexion échoue, affiche un message d'erreur à l'utilisateur
  373.                 $responseBody = json_decode($e->getMessage());
  374.                 $this->addFlash('danger', $responseBody);
  375.             }
  376.         }
  377.         //redirection et envoie de la vue
  378.         return $this->render('security/reset_password/check_password.html.twig', [
  379.         ]);
  380.     }
  382.     #[Route('/reset_password/reset/{token}', name: 'app_reset_password_token')]
  383.     public function reset($token, Request $request): Response
  384.     {
  385.         
  386.         // Soumission du formulaire et validation
  387.         if ($request->isMethod('POST')) {
  389.             $password = $request->request->get('password');
  390.             try {
  391.                 $response = $this->registrationService->resetPost([
  392.                     'password' => $password,
  393.                     'token' => $token
  394.                 ]);
  395.                 $statusCode = $response->getStatusCode();
  396.                 
  397.                 if ($statusCode === 200 || $statusCode === 201 || $statusCode === 202) {
  399.                     $this->addFlash('success', "Mot de passe réinitialisé avec succès.");
  400.                     return  $this->redirectToRoute('app_login');
  401.                 } else {
  402.                     $this->addFlash('danger', "Erreur de réinitialisation");
  403.                     return  $this->redirectToRoute('app_login');
  404.                 }
  406.             } catch (Exception $e) {
  407.                 // Si la connexion échoue, affiche un message d'erreur à l'utilisateur
  408.                 $responseBody = json_decode($e->getMessage());
  409.                 $this->addFlash('danger', $responseBody);
  410.             }
  411.         }
  412.         //redirection et envoie de la vue
  413.         return $this->render('security/reset_password/reset.html.twig', [
  414.             'token' => $token
  415.         ]);
  416.     }
  417.     // endregion
  418. }