src/Controller/RegistrationController.php line 83

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\User;
  6. use App\Entity\Autres;
  7. use App\Entity\Adresse;
  8. use App\Entity\AgentInterne;
  9. use App\Entity\ChargeAssistance;
  10. use App\Entity\ChargeFormation;
  11. use App\Entity\Dae;
  12. use App\Entity\Delegation;
  13. use App\Entity\EnterprisePartenaire;
  14. use App\Form\AutresType;
  15. use App\Form\AdresseType;
  16. use App\Entity\Entreprise;
  17. use App\Entity\Partenaire;
  18. use App\Entity\Particulier;
  19. use App\Form\AgentInterneType;
  20. use App\Form\ChargeAssistanceType;
  21. use App\Form\ChargeFormationType;
  22. use App\Form\EntrepriseType;
  23. use App\Form\PartenaireNationalType;
  24. use App\Form\DaeType;
  25. use App\Form\PartenaireRegionalType;
  26. use App\Form\PartenaireType;
  27. use App\Form\ParticulierType;
  28. use App\Security\EmailVerifier;
  29. use App\Form\RegistrationFormType;
  30. use App\Repository\UserRepository;
  31. use App\Service\JwtService;
  32. use App\Service\SendMailService;
  33. use Symfony\Component\Mime\Address;
  34. use App\Repository\AdresseRepository;
  35. use App\Repository\DelegationRepository;
  36. use App\Repository\EnterprisePartenaireRepository;
  37. use App\Repository\GouvernoratRepository;
  38. use Doctrine\DBAL\Driver\Mysqli\Initializer\Charset;
  39. use Doctrine\ORM\EntityManagerInterface;
  40. use Doctrine\Persistence\ManagerRegistry;
  41. use Symfony\Bridge\Twig\Mime\TemplatedEmail;
  42. use Symfony\Component\HttpFoundation\Request;
  43. use Symfony\Component\HttpFoundation\Response;
  44. use Symfony\Component\Routing\Annotation\Route;
  45. use Symfony\Component\HttpFoundation\RequestStack;
  46. use Symfony\Component\Security\Http\Authentication\UserAuthenticatorInterface;
  47. use Symfony\Component\String\Slugger\SluggerInterface;
  48. use Symfony\Contracts\Translation\TranslatorInterface;
  49. use Symfony\Component\Mailer\Exception\TransportException;
  50. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  51. use Symfony\Component\HttpFoundation\JsonResponse;
  52. use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
  53. use SymfonyCasts\Bundle\VerifyEmail\Exception\VerifyEmailExceptionInterface;
  54. use SymfonyCasts\Bundle\VerifyEmail\VerifyEmailHelperInterface;
  55. use App\Security\UsersAuthenticator;
  56. use App\Service\FileUploader;
  58. class RegistrationController extends AbstractController
  59. {
  60.     private $verifyEmailHelper;
  61.     private EmailVerifier $emailVerifier;
  62.     private $request;
  63.         /**
  64.      * @var FileUploader
  65.      */
  66.     protected $fileUploader;
  68.     /**
  69.      * @param RequestStack $request
  70.      */
  71.     public function __construct(EmailVerifier $emailVerifier, RequestStack $request,
  72.     FileUploader $fileUploader,
  73.     VerifyEmailHelperInterface $helper,)
  74.     {
  75.         $this->emailVerifier = $emailVerifier;
  76.         $this->request = $request;
  77.         $this->verifyEmailHelper = $helper;
  78.         $this->fileUploader = $fileUploader;
  79.     }
  82.     #[Route('/register', name: 'app_register')]
  83.     public function register(
  84.         Request $request,
  85.         UserPasswordHasherInterface $userPasswordHasher,
  86.         EntityManagerInterface $entityManager,
  87.         UserRepository $userRepository,
  88.         GouvernoratRepository $gouvernoratRepository,
  89.         DelegationRepository $delegationRepository,
  90.         SendMailService $mailService,
  91.         JwtService $jwtService,
  93.         UserAuthenticatorInterface $userAuthenticator,
  94.         UsersAuthenticator $authenticator
  95.     ): Response {
  96.         $form_view_array = [];
  97.         $requestedType = null;
  98.         $request = $this->request->getCurrentRequest();
  99.         $adresse = new Adresse();
  100.         $formAdr = $this->createForm(AdresseType::class);
  102.         $types = [
  103.             User::PARTIICULIER,
  104.             User::ENTREPRISE,
  105.             Partenaire::PARTENAIRE_NATIONAL,
  106.             Partenaire::PARTENAIRE_REGIONAL,
  107.             
  109.         ];
  111.         $instance_array = [
  112.             User::PARTIICULIER => new Particulier(),
  113.             User::ENTREPRISE  => new Entreprise(),
  114.             Partenaire::PARTENAIRE_NATIONAL => new Partenaire(),
  115.             Partenaire::PARTENAIRE_REGIONAL => new Partenaire(),
  116.             User::AUTRES  => new Autres(),
  118.         ];
  120.         $form_type_array = [
  121.             User::ENTREPRISE  => EntrepriseType::class,
  122.             User::PARTIICULIER => ParticulierType::class,
  123.             Partenaire::PARTENAIRE_REGIONAL => PartenaireRegionalType::class,
  124.             Partenaire::PARTENAIRE_NATIONAL => PartenaireNationalType::class,
  125.             User::AUTRES => AutresType::class,
  126.         ];
  128.         $role_array = [
  129.             User::PARTIICULIER  => 'ROLE_PARTICULIER',
  130.             User::ENTREPRISE  => 'ROLE_ENTREPRISES',
  131.             Partenaire::PARTENAIRE_REGIONAL  => 'ROLE_PARTENAIRES_REGIONAUX',
  132.             Partenaire::PARTENAIRE_NATIONAL  => 'ROLE_PARTENAIRES_NATIONAUX',
  133.             User::AUTRES => 'ROLE_AUTRES',
  134.         ];
  136.         $formAdr->handleRequest($request);
  138.         foreach ($types as $type) {
  139.             $instance = $instance_array[$type];
  140.             $form = $this->createForm($form_type_array[$type], $instance);
  141.             //$instance->addAdress(new Adresse());
  142.             $form_view_array[$type] = $form->createView();
  144.             $form->handleRequest($request);
  145.             if ($form->isSubmitted()) {
  146.                 if ($type == "Entreprise" and count($instance->getAdresses()) > 0) {
  147.                     foreach ($request->request->all()[strtolower($type)]['adresses'] as $i => $elem) {
  148.                         $deleg =  $delg = $delegationRepository->findOneBy(['id' => $elem['delegation']]);
  149.                         $instance->getAdresses()[$i]->setDelegation($deleg);
  150.                         $instance->getAdresses()[$i]->setUser($instance);
  151.                         $instance->getAdresses()[$i]->setAdresse($elem['adresse']);
  152.                         
  153.                     }
  154.                 }
  156.                 if ($type == "Entreprise" and $instance->getChargeFormations()) {
  157.                     /** mapping of created User */
  158.                     foreach ($instance->getChargeFormations() as $elem) {
  159.                         $elem->setEntreprise($instance);
  160.                     }
  161.                 }
  164.                 if (($type == "Partenaire_national" or $type == "Partenaire_regional") and $instance->getAdresses()) {
  165.                     $adress = new Adresse();
  166.                     $deleg = $delegationRepository->findOneBy(['id' => $request->request->all()[strtolower($type)]['delegation']]);
  167.                     $gouv = $gouvernoratRepository->findOneBy(['id' => $request->request->all()[strtolower($type)]['gouvernorat']]);
  168.                     $adress->setDelegation($deleg);
  169.                     $adress->setGouvernorat($gouv);
  170.                     $adress->setCodePostale($request->request->all()[strtolower($type)]['code_postale']);
  171.                     $adress->setAdresse($request->request->all()[strtolower                                                                                                                                                                                       ($type)]['adresse']);
  172.                     $instance->addAdress($adress);
  173.                 }
  175.                 if ($type == "Partenaire_national" or $type == "Partenaire_regional") {
  177.                     $instance->setTypePartenaire($type);
  179.                     /** mapping of created User */
  180.                     foreach ($instance->getEnterprisePartenaires() as $elem) {
  181.                         $elem->setEntreprisePartenaire($instance);
  182.                     }
  183.                 }
  185.                 if (($type == "Autres"  or $type == "Particulier") and $instance->getAdresses()) {
  186.                     $adress = new Adresse();
  187.                     $gouv = $gouvernoratRepository->findOneBy(['id' => $request->request->all()[strtolower($type)]['gouvernorat']]);
  188.                     $adress->setGouvernorat($gouv);
  189.                     $adress->setCodePostale($request->request->all()[strtolower($type)]['code_postale']);
  190.                     $adress->setAdresse($request->request->all()[strtolower($type)]['adresse']);
  191.                     $instance->addAdress($adress);
  192.                 }
  196.                 $requestedType = $type;
  197.                 $requestedParams = $request->request->all()[strtolower($type)];
  198.        
  199.                 if ($form->get('plainPassword')->getData() != null) {
  200.                     if (strcmp($form->get('plainPassword')->getData(), $form->get('confirmpassword')->getData()) == 0) {
  201.                         if ($form->get('plainPassword')->getData() != null) {
  202.                             $instance->setPassword(
  203.                                 $userPasswordHasher->hashPassword(
  204.                                     $instance,
  205.                                     $form->get('plainPassword')->getData()
  206.                                 )
  207.                             );
  208.                         }
  209.                     } else {
  210.                         return new JsonResponse([
  211.                             'success' => false,
  212.                             'message' => 'Les mots de passe ne sont pas identiques !'
  213.                             
  214.                         ], Response::HTTP_OK, ['Content-Type', 'application/json']);
  215.                     }
  216.                 }
  217.     
  218.                 // set roles
  219.                 $instance->setRoles(array($role_array[$type]));
  221.                 // set gouvernorat
  222.                 if (array_key_exists('gouvernorat', $requestedParams)) {
  223.                     $gouv = $gouvernoratRepository->findOneBy(['id' => $requestedParams['gouvernorat']]);
  224.                     $adresse->setGouvernorat($gouv);
  225.                 }
  227.                 // set delegation if exist
  228.                 if (array_key_exists('delegation', $requestedParams)) {
  229.                     $delg = $delegationRepository->findOneBy(['id' => $requestedParams['delegation']]);
  230.                     $adresse->setDelegation($delg);
  231.                 }
  233.                 // set adresse if exist
  234.                 if (array_key_exists('adresse', $requestedParams)) {
  235.                     $adresse->setAdresse($requestedParams['adresse']);
  236.                 }
  238.                 // set Localite if exist
  239.                 if (array_key_exists('Localite', $requestedParams)) {
  240.                     $adresse->setLocalite($requestedParams['Localite']);
  241.                 }
  243.                 // set code postale
  244.                 if (array_key_exists('code_postale', $requestedParams)) {
  245.                     $adresse->setCodePostale($requestedParams['code_postale']);
  246.                 }
  247.                 
  248.                 if (!$userRepository->findOneBy(['email' => $form->get('email')->getData()])) {
  249.                   //dd($instance);
  250.                   $entityManager->persist($instance);
  251.                   $entityManager->flush();
  253.                   // On génère le JWT de l'utilisateur
  254.                   // On crée le Header
  255.                   $header = [
  256.                       'typ' => 'JWT',
  257.                       'alg' => 'HS256'
  258.                   ];
  260.                   // On crée le Payload
  261.                   $payload = [
  262.                       'user_id' => $instance->getId()
  263.                   ];
  264.                   // On génère le token
  265.                   $token = $jwtService->generate($header, $payload, $this->getParameter('app.jwtsecret'));
  267.                   // On envoie un mail
  268.                   $mailService->send(
  269.                       $this->getParameter('EmailAdmin'),
  270.                       $instance->getEmail(),
  271.                       'Activation de votre compte',
  272.                       'emails/register_mail.html.twig',
  273.                       ['username' => $instance->getUsername(), 'token' => $token],
  274.                   );
  276.                   return new JsonResponse([
  277.                       'success' => true,
  278.                       'message' => 'Votre compte a été créé avec succès, vérifiez votre boite mail pour le confirmer!'
  279.                       
  280.                   ], Response::HTTP_OK, ['Content-Type', 'application/json']);
  281.                  
  282.                 } else {
  283.                     return new JsonResponse([
  284.                         'success' => false,
  285.                         'message' => 'Email existe déjà !'
  286.                         
  287.                     ], Response::HTTP_OK, ['Content-Type', 'application/json']);
  288.                    
  289.                 }
  290.             }
  291.         }
  293.         return $this->render('registration/register.html.twig', [
  294.             'form_view_array' => $form_view_array,
  295.             'types' => $types,
  296.             'formAdr' => $formAdr->createView(),
  297.             'requestedType' => $requestedType
  298.         ]);
  300.     }
  303.     #[Route('ajax/get/delegation', name: 'ajax_get_delegation')]
  304.     public function getDelegation(Request $request, TranslatorInterface $translator, EntityManagerInterface $em): JsonResponse
  305.     {
  306.         $delegations = $em
  307.             ->getRepository(Delegation::class)
  308.             ->getDelegationByGouvernaurat($request->query->get('gouvernorat_id'));
  309.         return new JsonResponse(json_encode($delegations));
  310.     }
  313.     #[Route('/verify/email', name: 'app_verify_email')]
  314.     public function verifyUserEmail(Request $request, TranslatorInterface $translator, VerifyEmailHelperInterface $verifyEmailHelper): Response
  315.     {
  316.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  317.         $user = $this->getUser();
  319.         // Do not get the User's Id or Email Address from the Request object
  320.         try {
  321.             $this->verifyEmailHelper->validateEmailConfirmation($request->getUri(), $user->getId(), $user->getEmail());
  322.         } catch (VerifyEmailExceptionInterface $e) {
  323.             $this->addFlash('verify_email_error', $e->getReason());
  325.             return $this->redirectToRoute('app_register');
  326.         }
  328.         // Mark your user as verified. e.g. switch a User::verified property to true
  330.         $this->addFlash('success', 'Your e-mail address has been verified.');
  332.         return $this->redirectToRoute('accueil');
  333.     }
  334.     #[Route('/profil', name: 'app_profil')]
  335. public function app_profil(
  336.     Request $request,
  337.     SluggerInterface $slugger,
  338.     EntityManagerInterface $entityManager,
  339.     ManagerRegistry $registry,
  340.     GouvernoratRepository $gouvernoratRepository,
  341.     DelegationRepository $delegationRepository,
  342.     UserPasswordHasherInterface $userPasswordHasher,
  343.     EnterprisePartenaireRepository $enterprisePartenaireRepository,
  344.     UserRepository $userRepository,
  345.     AdresseRepository $adresseRepository
  346. ): Response {
  347.     $AdresseRepository = $entityManager->getRepository(Adresse::class);
  348.     $adr = $AdresseRepository->findOneBy(['user' => $this->getUser()]);
  350.     // Vérification utilisateur connecté
  351.     if (!$this->getUser()) {
  352.         return $this->redirectToRoute('login');
  353.     }
  355.     // Création du formulaire en fonction du type d’utilisateur
  356.     $form = null;
  358.     if ($this->getUser() instanceof Partenaire) {
  359.         if ($this->getUser()->getTypePartenaire() === Partenaire::PARTENAIRE_REGIONAL) {
  360.             $form = $this->createForm(PartenaireRegionalType::class, $this->getUser());
  361.         } elseif ($this->getUser()->getTypePartenaire() === Partenaire::PARTENAIRE_NATIONAL) {
  362.             $form = $this->createForm(PartenaireNationalType::class, $this->getUser());
  363.         }
  364.     } elseif ($this->getUser() instanceof Particulier) {
  365.         $form = $this->createForm(ParticulierType::class, $this->getUser());
  366.     } elseif ($this->getUser() instanceof Entreprise) {
  367.         $form = $this->createForm(EntrepriseType::class, $this->getUser());
  368.     } elseif ($this->getUser() instanceof Autres) {
  369.         $form = $this->createForm(AutresType::class, $this->getUser());
  370.     } elseif ($this->getUser() instanceof Dae) {
  371.         $form = $this->createForm(DaeType::class, $this->getUser());
  372.     } elseif ($this->getUser() instanceof ChargeAssistance) {
  373.         $form = $this->createForm(ChargeAssistanceType::class, $this->getUser());
  374.     } elseif ($this->getUser() instanceof AgentInterne) {
  375.         $form = $this->createForm(AgentInterneType::class, $this->getUser());
  376.     }
  378.     // Si aucun formulaire trouvé → erreur explicite
  379.     if (!$form) {
  380.         throw $this->createNotFoundException('Aucun formulaire défini pour ce type d’utilisateur.');
  381.     }
  383.     // Traitement du formulaire
  384.     $form->handleRequest($request);
  386.     if ($form->isSubmitted() && $form->isValid()) {
  387.         $data = $request->request->all();
  389.         if ($this->getUser() instanceof Particulier) {
  390.             $gouv = $gouvernoratRepository->find((int)$data['particulier']['gouvernorat']);
  391.             $adr->setGouvernorat($gouv);
  392.             $adr->setAdresse($data['particulier']['adresse']);
  393.             $adr->setCodePostale($data['particulier']['code_postale']);
  394.         } elseif ($this->getUser() instanceof Dae) {
  395.             $gouv = $gouvernoratRepository->find((int)$data['dae']['gouvernorat']);
  396.             $adr->setGouvernorat($gouv);
  397.             $adr->setAdresse($data['dae']['adresse']);
  398.             $adr->setCodePostale($data['dae']['code_postale']);
  399.         } elseif ($this->getUser() instanceof Entreprise) {
  400.             foreach ($this->getUser()->getChargeFormations() as $elem) {
  401.                 $elem->setEntreprise($this->getUser());
  402.             }
  403.         } elseif ($this->getUser() instanceof Partenaire) {
  404.             $type = $this->getUser()->getTypePartenaire() === Partenaire::PARTENAIRE_NATIONAL
  405.                 ? "partenaire_national"
  406.                 : "partenaire_regional";
  408.             $gouv = $gouvernoratRepository->find((int)$data[$type]['gouvernorat']);
  409.             $delg = $delegationRepository->find((int)$data[$type]['delegation']);
  410.             $adr->setGouvernorat($gouv);
  411.             $adr->setDelegation($delg);
  412.             $adr->setAdresse($data[$type]['adresse']);
  413.             $adr->setCodePostale($data[$type]['code_postale']);
  415.             $file = $request->files->get($type)['fileName'] ?? null;
  416.             if ($file) {
  417.                 $newFileName = $this->fileUploader->upload($file, '/listEnt', 'docEnt');
  418.                 $this->getUser()->setFileName($newFileName);
  419.             }
  420.         } elseif ($this->getUser() instanceof Autres) {
  421.             $gouv = $gouvernoratRepository->find((int)$data['autres']['gouvernorat']);
  422.             $adr->setGouvernorat($gouv);
  423.             $adr->setAdresse($data['autres']['adresse']);
  424.             $adr->setCodePostale($data['autres']['code_postale']);
  425.         }
  427.         // Vérification mot de passe
  428.         if ($form->get('plainPassword')->getData()) {
  429.             if ($form->get('plainPassword')->getData() === $form->get('confirmpassword')->getData()) {
  430.                 $this->getUser()->setPassword(
  431.                     $userPasswordHasher->hashPassword(
  432.                         $this->getUser(),
  433.                         $form->get('plainPassword')->getData()
  434.                     )
  435.                 );
  436.             } else {
  437.                 return new JsonResponse([
  438.                     'success' => false,
  439.                     'message' => 'Les mots de passe ne sont pas identiques !'
  440.                 ]);
  441.             }
  442.         }
  444.         $entityManager->persist($this->getUser());
  445.         $entityManager->flush();
  447.         return new JsonResponse([
  448.             'success' => true,
  449.             'message' => 'Profil mis à jour avec succès'
  450.         ]);
  451.     }
  453.     return $this->render('registration/profil.html.twig', [
  454.         'profilForm' => $form->createView(),
  455.         'adr' => $adr
  456.     ]);
  457. }
  460.     #[Route('/verif/{token}', name: 'verify_user')]
  461.     public function verifyUser($token, JwtService $jwt, UserRepository $userRepository, EntityManagerInterface $em): Response
  462.     {
  463.         //On vérifie si le token est valide, n'a pas expiré et n'a pas été modifié
  464.         if ($jwt->isValid($token) && !$jwt->isExpired($token) && $jwt->check($token, $this->getParameter('app.jwtsecret'))) {
  465.             // On récupère le payload
  466.             $payload = $jwt->getPayload($token);
  468.             // On récupère le user du token
  469.             $user = $userRepository->find($payload['user_id']);
  471.             //On vérifie que l'utilisateur existe et n'a pas encore activé son compte
  472.             if ($user && !$user->isVerified()) {
  473.                 $user->setIsVerified(true);
  474.                 $em->flush($user);
  475.                 $this->addFlash('success', 'Utilisateur activé');
  476.                 return $this->redirectToRoute('app_profil');
  477.             }
  478.         }
  479.         // Ici un problème se pose dans le token
  480.         $this->addFlash('danger', 'Le token est invalide ou a expiré');
  481.         return $this->redirectToRoute('login');
  482.     }
  484.     #[Route('/renvoiverif', name: 'resend_verif')]
  485.     public function resendVerif(JWTService $jwt, SendMailService $mail, UserRepository $userRepository): Response
  486.     {
  487.         $user = $this->getUser();
  489.         if (!$user) {
  490.             $this->addFlash('danger', 'Vous devez être connecté pour accéder à cette page');
  491.             return $this->redirectToRoute('login');
  492.         }
  494.         if ($user->isVerified()) {
  495.             $this->addFlash('warning', 'Cet utilisateur est déjà activé');
  496.             return $this->redirectToRoute('app_profil');
  497.         }
  499.         // On génère le JWT de l'utilisateur
  500.         // On crée le Header
  501.         $header = [
  502.             'typ' => 'JWT',
  503.             'alg' => 'HS256'
  504.         ];
  506.         // On crée le Payload
  507.         $payload = [
  508.             'user_id' => $user->getId()
  509.         ];
  511.         // On génère le token
  512.         $token = $jwt->generate($header, $payload, $this->getParameter('app.jwtsecret'));
  514.         // On envoie un mail
  515.         $mail->send(
  516.             $this->getParameter('EmailAdmin'),
  517.             $user->getEmail(),
  518.             'Activation de votre compte sur le site e-commerce',
  519.             'register',
  520.             compact('user', 'token')
  521.         );
  522.         $this->addFlash('success', 'Email de vérification envoyé');
  523.         return $this->redirectToRoute('app_profil');
  524.     }
  526.      protected function executeAction(Request $request): Response
  527.     {
  528.         // Récupérez les données soumises
  529.         $montant = $request->request->get('entreprise_montant');
  531.         // Effectuez la validation et l'enregistrement
  532.         if (floatval($montant) === 0) {
  533.             return new Response('Le montant ne peut pas être zéro.', 400);
  534.         }
  536.         // Effectuez l'enregistrement dans la base de données
  538.         return new Response('Enregistrement réussi !');
  539.     }
  541.     #[Route('/general-conditions', name: 'app_general_conditions')]
  542.     public function generalConditions(){
  543.         return $this->render('registration/general_conditions.html.twig', []);
  544.     }
  545. }