src/Controller/Security/SecurityController.php line 97

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Security;
  5. use App\Ressources\FakeData;
  6. use App\Entity\Security\User;
  7. use App\Form\Security\LoginFormType;
  8. use App\Service\SmsGeneratorService;
  9. use App\Service\UwandzaniApiService;
  10. use Doctrine\ORM\EntityManagerInterface;
  11. use App\Service\Security\SecurityService;
  12. use App\Form\Security\RegistrationFormType;
  13. use App\Repository\Security\UserRepository;
  14. use Symfony\Component\HttpFoundation\Request;
  15. use Symfony\Component\HttpFoundation\Response;
  16. use Symfony\Component\Routing\Annotation\Route;
  17. use KnpU\OAuth2ClientBundle\Client\ClientRegistry;
  18. use Symfony\Component\HttpFoundation\JsonResponse;
  19. use App\Services\Notification\NotificationMailService;
  20. use Symfony\Component\Security\Csrf\CsrfTokenManagerInterface;
  21. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  22. use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
  23. use Lexik\Bundle\JWTAuthenticationBundle\Services\JWTTokenManagerInterface;
  25. final class SecurityController extends AbstractController
  26. {
  27.     private EntityManagerInterface $em;
  28.     private UserPasswordHasherInterface $passwordHasher;
  29.     private FakeData $fakeData;
  30.     private JWTTokenManagerInterface $JWTTokenManager;
  31.     private UwandzaniApiService $uwandzaniApiService;
  32.     private SmsGeneratorService $smsGenerator;
  33.     private CsrfTokenManagerInterface $csrfTokenManager;
  34.     private UserRepository $userRepository;
  35.     private SecurityService $securityService;
  36.     //private NotificationMailService $notificationMailService;
  38.     public const SCOPES = [
  39.         'google' => [],
  40.         'facebook' => [
  41.             'email',
  42.             'public_profile',
  43.             'user_friends',
  44.             'pages_show_list',
  45.             'phone',
  46.             'pages_read_engagement',
  47.             'pages_manage_metadata',
  48.             'pages_read_user_content',
  49.             'pages_manage_ads',
  50.             'pages_manage_engagement',
  51.             'pages_manage_posts',
  52.             'pages_manage_read',
  53.             'pages_manage_comments',
  54.             'pages_manage_jobs',
  55.             'pages_manage_leads',
  56.         ],
  57.         'apple' => [],
  58.         'instagram' => [],
  59.         'uber' => [],
  60.         'phone' => [],
  61.         'email' => [],
  62.     ];
  64.     public function __construct(
  65.         EntityManagerInterface $em,
  66.         UserPasswordHasherInterface $passwordHasher,
  67.         FakeData $fakeData,
  68.         JWTTokenManagerInterface $JWTTokenManager,
  69.         UwandzaniApiService $uwandzaniApiService,
  70.         SmsGeneratorService $smsGenerator,
  71.         CsrfTokenManagerInterface $csrfTokenManager,
  72.         UserRepository $userRepository,
  73.         SecurityService $securityService
  74.     ) {
  75.         $this->em = $em;
  76.         $this->passwordHasher = $passwordHasher;
  77.         $this->fakeData = $fakeData;
  78.         $this->JWTTokenManager = $JWTTokenManager;
  79.         $this->uwandzaniApiService = $uwandzaniApiService;
  80.         $this->smsGenerator = $smsGenerator;
  81.         $this->csrfTokenManager = $csrfTokenManager;
  82.         $this->userRepository = $userRepository;
  83.         $this->securityService = $securityService;
  84.         //$this->notificationMailService = $notificationMailService;
  85.     }
  87.     /******************************
  88.      *  Affiche le formulaire web
  89.      * de connexion
  90.      * Et le formulaire web
  91.      * d'inscription
  92.      * ***************************/
  93.     /**
  94.      * @Route("/", name="app_login", methods={"GET", "POST"})
  95.      * @Route("/app-registration", name="app_home_regisatration", methods={"GET", "POST"})
  96.      */
  97.     public function homePage(
  98.         Request $request,
  99.         EntityManagerInterface $em,
  100.         UserPasswordHasherInterface $passwordHasher
  101.     ): Response {
  103.         if ($this->getUser()) {
  104.             return $this->redirectToRoute('app_project_project_task_position_index');
  105.         }
  106.         // Créer les formulaires sans passer manuellement le jeton CSRF
  107.         $loginForm = $this->createForm(LoginFormType::class);
  108.         $registrationForm = $this->createForm(RegistrationFormType::class);
  110.         $loginForm->handleRequest($request);
  111.         $registrationForm->handleRequest($request);
  113.         // Traiter l'enregistrement
  114.         if ($registrationForm->isSubmitted() && $registrationForm->isValid()) {
  115.             $data = $registrationForm->getData();
  117.             $user = new User();
  118.             $user->setEmail($data['email']);
  120.             // Hachage du mot de passe
  121.             $hashedPassword = $passwordHasher->hashPassword(
  122.                 $user,
  123.                 $data['password']
  124.             );
  125.             $user->setPassword($hashedPassword);
  127.             // Enregistrer l'utilisateur dans la base de données
  128.             $em->persist($user);
  129.             $em->flush();
  131.             $this->addFlash('success', 'Inscription réussie !');
  132.             // Rediriger l'utilisateur après inscription réussie
  133.             return $this->redirectToRoute('app_home_project_index');
  134.         }
  136.         return $this->render('security/home.html.twig', [
  137.             'form_login' => $loginForm->createView(),
  138.             'form_registration' => $registrationForm->createView(),
  139.         ]);
  140.     }
  142.     /////////////////////////// Login //////////////////////////
  144.     /******************************
  145.      * Authentification de l'utilisateur
  146.      * à partir du web
  147.      ***************************/
  148.     /**
  149.      * @Route("/auth/login", name="login", methods={"GET"})
  150.      */
  151.     public function loginFromWeb(): Response
  152.     {
  153.         if ($this->getUser()) {
  154.             return $this->redirectToRoute('home');
  155.         }
  156.         return $this->render('security/login.html.twig');
  157.     }
  159.     /******************************
  160.      * Récupère l'identifiant Authentification de l'utilisateur
  161.      * à partir de l'API
  162.      * 
  163.      * Si l'utilisateur n'existe pas, il est créé
  164.      * et un code de vérification est envoyé
  165.      ***************************/
  166.     /**
  167.      * @Route("/get-login-identifier-from-api", name="api_get_login_identifier_from_api", methods={"POST"})
  168.      */
  169.     public function createAndLoginFromApi(Request $request, UserRepository $userRepository): JsonResponse
  170.     {
  171.         $user = null;
  172.         $data = json_decode($request->getContent(), true);
  174.         $isUwandzaniIdentifier = $data['isUwandzaniIdentifier'] ?? false;
  175.         $identifier = $data['identifier'] ?? null;
  176.         $identifierType = $data['identifierType'] ?? null;
  177.         $hashSMS = $data['hashSMS'] ?? null;
  178.         $plainPassword = $data['password'] ?? null;
  180.         /***********************
  181.          * Vérifie si l'utilisateur existe
  182.          * ************************/
  183.         if ($identifier) {
  184.             $user = $this->findUserByCredentials($identifier);
  185.         }
  187.         // Si l'utilisateur n'est pas trouvé, on crée l'utilisateur
  188.         if (!$user && array_key_exists($identifierType, self::SCOPES) && !$isUwandzaniIdentifier) {
  189.             $user =  $this->createUser($identifier, $identifierType, $hashSMS, $plainPassword);
  190.             //$sendVerificationCode = false;
  191.         }
  194.         if ($isUwandzaniIdentifier) {
  195.             $uwandzaniCredantials = $this->uwandzaniApiService->retreiveUwandzaniCredantials(
  196.                 $identifier,
  197.                 $identifierType,
  198.                 $plainPassword,
  199.                 $hashSMS
  200.             );
  203.             $this->findOrCreateUserWithUwandzani([
  204.                 'uwandzaniId' => $uwandzaniCredantials['uwandzaniId'],
  205.                 'identifier' => $uwandzaniCredantials['identifier'],
  206.                 'identifierType' => $uwandzaniCredantials['identifierType'],
  207.                 'hashSMS' => $uwandzaniCredantials['hashSMS'],
  208.                 'plainPassword' => $uwandzaniCredantials['plainPassword'],
  209.             ], $userRepository);
  212.             if (!$user) {
  213.                 return new JsonResponse(['message' => 'Code de validation incorrect ou utilisateur non trouvé.'], 401);
  214.             }
  215.         } elseif ($identifierType === self::SCOPES['phone']) {
  216.             if ($identifier !== '+33782615889') {
  217.                 // On continue
  218.             } elseif (
  219.                 $identifierType === self::SCOPES['phone']
  220.             ) {
  221.                 $this->generateVerificationCode($user, $hashSMS, $identifierType);
  222.             }
  223.         } elseif ($identifierType === self::SCOPES['email']) {
  225.             /***
  226.              * On vérifie que le mot de passe entrée 
  227.              * Corespond à celui de l'utilisateur
  228.              * Si c'est le cas, on continue
  229.              */
  230.             if ($plainPassword) {
  231.                 if (!$this->passwordHasher->isPasswordValid($user, $plainPassword)) {
  232.                     return new JsonResponse(['message' => 'Au mo'], 401);
  233.                 }
  234.             }
  235.         } elseif ($identifierType === self::SCOPES['google']) {
  236.             // code...
  237.         } elseif ($identifierType === self::SCOPES['facebook']) {
  238.             // code...
  239.         } elseif ($identifierType === self::SCOPES['apple']) {
  240.             // code...
  241.         } elseif ($identifierType === self::SCOPES['instagram']) {
  242.             // code...
  243.         } elseif ($identifierType === self::SCOPES['uber']) {
  244.             // code...
  245.         }
  247.         /***********************
  248.          * Si c'est une identification par Uwandzani
  249.          * On lui renvoie seulement l'identifiant public
  250.          * 
  251.          * Ensuitel'application cliente devra générer son jeton
  252.          * d'authentification pour l'utilisateur
  253.          ***********************/
  254.         if ($user && $isUwandzaniIdentifier) {
  255.             return new JsonResponse(
  256.                 ['uwandzaniId' => $user->getUuid()],
  257.                 200
  258.             );
  259.         }
  261.         if (!$user) {
  262.             return new JsonResponse(['message' => 'Aucun moyen de connexion valide fourni.'], 400);
  263.         }
  265.         /**********************
  266.          * Si l'utilisateur est trouvé
  267.          * Et que ce n'est pas une athentification par Uwandzani
  268.          * On lui envoie un code de vérification
  269.          **************************/
  270.         $token = $this->securityService->createAndUpdateJwtToken($user);
  272.         return new JsonResponse([
  273.             'message' => 'Connexion réussie',
  274.             'token' => $token,
  275.             'user' => [
  276.                 'uuid' => $user->getUuid(),
  277.                 'email' => $user->getEmail(),
  278.             ]
  279.         ], 200);
  280.     }
  282.     // $recaptchaResponse = $request->get('recaptcha-response');
  283.     //     if ($form->isSubmitted() && $form->isValid() && $this->isNotRobot($recaptchaResponse)) {
  286.     /******************************
  287.      * Verifie le code de vérification
  288.      * de l'utilisateur
  289.      * 
  290.      * Si le code est correct, l'utilisateur
  291.      * est vérifié et un jeton d'authentification
  292.      * est généré et renvoyé au client
  293.      * Pour être connécté coté client
  294.      * ***************************/
  295.     /**
  296.      * @Route("/chek-verification-code", name="chek_verification_code", methods={"POST"})
  297.      */
  298.     public function chekVerificationCode(Request $request): JsonResponse
  299.     {
  300.         $data = json_decode($request->getContent(), true);
  302.         $identifier = $data['identifier'] ?? null;
  303.         $verificationCode = $data['verificationCode'] ?? null;
  304.         $identifierType = $data['identifierType'] ?? null;
  305.         $hashSMS = $data['hashSMS'] ?? null;
  306.         $plainPassword = $data['password'] ?? null;
  308.         $user = null;
  310.         if ($identifier) {
  311.             $user = $this->findUserByCredentials($identifier);
  312.         }
  314.         if ($user && $verificationCode && $user->getVerificationCode() === $verificationCode && ((new \DateTime('now')) > $user->getVerificationCodeExpiresdAt())) {
  315.             $token = $this->securityService->createAndUpdateJwtToken($user);
  317.             $user
  318.                 ->setIsVerified(true)
  319.                 ->setVerificationCode(null);
  321.             $this->em->flush();
  323.             return new JsonResponse([
  324.                 'message' => 'Code de validation correct',
  325.                 'authToken' => $token,
  326.                 'user' => [
  327.                     'uuid' => $user->getUuid(),
  328.                     'email' => $user->getEmail(),
  329.                 ]
  330.             ], 200);
  331.         }
  333.         return new JsonResponse(['message' => 'Code incorrect ou expiré'], 401);
  334.     }
  336.     /******************************
  337.      * Rafraîchir le jeton d'authentification
  338.      * de l'utilisateur
  339.      * ***************************/
  340.     /**
  341.      * @Route("/api/pr/s/u/refresh-token", name="api_user_refresh_token", methods={"GET"})
  342.      */
  343.     public function refreshJwtToken(): JsonResponse
  344.     {
  345.         /** @var User $user */
  346.         $user = $this->getUser();
  348.         if (!$user) {
  349.             return new JsonResponse(['message' => 'Utilisateur non authentifié.'], 401);
  350.         }
  352.         $token = $this->securityService->createAndUpdateJwtToken($user);
  354.         return new JsonResponse([
  355.             'message' => 'Token rafraîchi avec succès',
  356.             'token' => $token,
  357.             'user' => $user->getUuid()
  358.         ]);
  359.     }
  362.     /*******************************************
  363.      * Créer un utilisateur avec réseau sociaux
  364.      *******************************************/
  365.     /***
  366.      * Créer un utilisateur avec un
  367.      * ID Uwandzani
  368.      ***/
  371.     private function findOrCreateUserWithUwandzani(array $uwandzaniCredantials, UserRepository $userRepository): Response
  372.     {
  373.         $identifier = $uwandzaniCredantials['identifier'] ?? null;
  374.         $identifierType = $uwandzaniCredantials['identifierType'] ?? null;
  375.         // $plainPassword = $uwandzaniCredantials['plainPassword'] ?? null;
  376.         $hashSMS = $uwandzaniCredantials['hashSMS'] ?? null;
  377.         $uwandzaniId = $uwandzaniCredantials['uwandzaniId'];
  379.         $user = $userRepository->findOneBy(['uwandzaniId' => $uwandzaniId]);
  380.         // Si l'utilisateur n'est pas trouvé, on crée l'utilisateur
  381.         if (!$user) {
  382.             $user =  $this->createUser($identifier, $identifierType, $hashSMS);
  383.         }
  385.         /**********************
  386.          * Si l'utilisateur est trouvé
  387.          * Et que ce n'est pas une athentification par Uwandzani
  388.          * On lui envoie un code de vérification
  389.          **************************/
  390.         $token = $this->securityService->createAndUpdateJwtToken($user);
  392.         return new JsonResponse([
  393.             'message' => 'Connexion réussie',
  394.             'token' => $token,
  395.             'user' => [
  396.                 'uuid' => $user->getUuid(),
  397.                 'email' => $user->getEmail(),
  398.             ]
  399.         ], 200);
  401.         return new JsonResponse(['message' => 'Utilisateur créé avec succès', 'uuid' => $user->getUuid()], 201);
  402.     }
  405.     /***********************************
  406.      * Créer un utilisateur avec un 
  407.      * ID Facebook
  408.      ********************************/
  409.     /**
  410.      * @Route("/pu/s/u/create-user/facebook", name="api_create_user_with_facebook", methods={"POST"})
  411.      */
  412.     public function createUserWithFacebook(Request $request, UserRepository $userRepository, ClientRegistry $clientRegistry): Response
  413.     {
  414.         if ($request->get('_route') === 'api_create_fake_users_with_facebook') {
  415.             $fakeUsers = $userRepository->findBy(['isForFake' => true]);
  416.             if ($fakeUsers) {
  417.                 return $this->redirectToRoute(
  418.                     'app_security_user_delete_fake_users',
  419.                     ["nextRoute" => "api_create_fake_users_with_facebook"]
  420.                 );
  421.             }
  423.             $userFakes = $this->fakeData->getUserFakeData();
  424.             $createdUsers = $this->createFakeUsersWithFacebook($userFakes);
  426.             return new JsonResponse([
  427.                 'message' => count($createdUsers) . ' utilisateurs fictifs créés avec succès.',
  428.                 'created_users' => $createdUsers,
  429.             ], 201);
  430.         }
  432.         $client = $clientRegistry->getClient('facebook');
  433.         $userInfo = $client->fetchUser();
  435.         // On vérifie si l'utilisateur existe déjà
  436.         $facebookId = $userInfo->getId();
  437.         $user = $userRepository->findOneBy(['facebookId' => $facebookId]);
  439.         if (!$user) {
  440.             // Créer un nouvel utilisateur si aucun utilisateur correspondant trouvé
  441.             $user = $this->createUserWithCredentials(
  442.                 $email = null,
  443.                 $phone = null,
  444.                 $hashSMS = null,
  445.                 $uwandzaniToken = null,
  446.                 $facebookId,
  447.                 $googleId = null,
  448.                 $appleId = null,
  449.                 $isForFake = false,
  450.                 $userData = []
  451.             );
  452.         }
  454.         return new JsonResponse([
  455.             'message' => 'Utilisateur Facebook créé avec succès',
  456.             'uuid' => $user->getUuid(),
  457.         ], 201);
  458.     }
  460.     /***********************************
  461.      * Créer un utilisateur avec un 
  462.      * ID Google
  463.      **********************************/
  465.     /**
  466.      * @Route("/pu/s/u/create-user/google", name="api_create_user_with_google", methods={"POST"})
  467.      */
  468.     public function createUserWithGoogle(Request $request, UserRepository $userRepository, ClientRegistry $clientRegistry): Response
  469.     {
  470.         if ($request->get('_route') === 'api_create_fake_users_with_google') {
  471.             $fakeUsers = $userRepository->findBy(['isForFake' => true]);
  472.             if ($fakeUsers) {
  473.                 return $this->redirectToRoute(
  474.                     'app_security_user_delete_fake_users',
  475.                     ["nextRoute" => "api_create_fake_users_with_google"]
  476.                 );
  477.             }
  479.             $userFakes = $this->fakeData->getUserFakeData();
  480.             $createdUsers = $this->createFakeUsersWithGoogle($userFakes);
  482.             return new JsonResponse([
  483.                 'message' => count($createdUsers) . ' utilisateurs fictifs créés avec succès.',
  484.                 'created_users' => $createdUsers,
  485.             ], 201);
  486.         }
  488.         $client = $clientRegistry->getClient('google');
  489.         $userInfo = $client->fetchUser();
  491.         $googleId = $userInfo->getId();
  492.         $user = $userRepository->findOneBy(['googleId' => $googleId]);
  494.         if (!$user) {
  495.             $user = $this->createUserWithCredentials(
  496.                 $email = null,
  497.                 $phone = null,
  498.                 $hashSMS = null,
  499.                 $uwandzaniToken = null,
  500.                 $facebookId = null,
  501.                 $googleId,
  502.                 $appleId = null,
  503.                 $isForFake = false,
  504.                 $userData = []
  505.             );
  506.         }
  508.         return new JsonResponse([
  509.             'message' => 'Utilisateur Google créé avec succès',
  510.             'uuid' => $user->getUuid(),
  511.         ], 201);
  512.     }
  515.     /*********************************
  516.      * Créer un utilisateur avec un 
  517.      * ID Apple
  518.      ********************************/
  520.     /**
  521.      * @Route("/pu/s/u/create-user/apple", name="api_create_user_with_apple", methods={"POST"})
  522.      */
  523.     public function createUserWithApple(Request $request, UserRepository $userRepository, ClientRegistry $clientRegistry): Response
  524.     {
  525.         if ($request->get('_route') === 'api_create_fake_users_with_apple') {
  526.             $fakeUsers = $userRepository->findBy(['isForFake' => true]);
  527.             if ($fakeUsers) {
  528.                 return $this->redirectToRoute(
  529.                     'app_security_user_delete_fake_users',
  530.                     ["nextRoute" => "api_create_fake_users_with_apple"]
  531.                 );
  532.             }
  534.             $userFakes = $this->fakeData->getUserFakeData();
  535.             $createdUsers = $this->createFakeUsersWithApple($userFakes);
  537.             return new JsonResponse([
  538.                 'message' => count($createdUsers) . ' utilisateurs fictifs créés avec succès.',
  539.                 'created_users' => $createdUsers,
  540.             ], 201);
  541.         }
  543.         $client = $clientRegistry->getClient('apple');
  544.         $userInfo = $client->fetchUser();
  546.         $appleId = $userInfo->getId();
  547.         $user = $userRepository->findOneBy(['appleId' => $appleId]);
  549.         if (!$user) {
  550.             // Créer un nouvel utilisateur si aucun utilisateur correspondant trouvé
  551.             $user = $this->createUserWithCredentials(
  552.                 $email = null,
  553.                 $phone = null,
  554.                 $hashSMS = null,
  555.                 $uwandzaniToken = null,
  556.                 $facebookId = null,
  557.                 $googleId = null,
  558.                 $appleId,
  559.                 $isForFake = false,
  560.                 $userData = []
  561.             );
  562.         }
  564.         return new JsonResponse([
  565.             'message' => 'Utilisateur Apple créé avec succès',
  566.             'uuid' => $user->getUuid(),
  567.         ], 201);
  568.     }
  570.     /**************************************
  571.      * Créer un utilisateur avec un 
  572.      * ID Instagram
  573.      ************************************/
  575.     /**
  576.      * @Route("/pu/s/u/create-user/instagram", name="api_create_user_with_instagram", methods={"POST"})
  577.      */
  578.     public function createUserWithInstagram(Request $request, UserRepository $userRepository, ClientRegistry $clientRegistry): Response
  579.     {
  580.         if ($request->get('_route') === 'api_create_fake_users_with_instagram') {
  581.             $fakeUsers = $userRepository->findBy(['isForFake' => true]);
  582.             if ($fakeUsers) {
  583.                 return $this->redirectToRoute(
  584.                     'app_security_user_delete_fake_users',
  585.                     ["nextRoute" => "api_create_fake_users_with_instagram"]
  586.                 );
  587.             }
  589.             $userFakes = $this->fakeData->getUserFakeData();
  590.             $createdUsers = $this->createFakeUsersWithInstagram($userFakes);
  592.             return new JsonResponse([
  593.                 'message' => count($createdUsers) . ' utilisateurs fictifs créés avec succès.',
  594.                 'created_users' => $createdUsers,
  595.             ], 201);
  596.         }
  598.         $client = $clientRegistry->getClient('instagram');
  599.         $userInfo = $client->fetchUser();
  601.         $instagramId = $userInfo->getId();
  602.         $user = $userRepository->findOneBy(['instagramId' => $instagramId]);
  604.         if (!$user) {
  605.             // Créer un nouvel utilisateur si aucun utilisateur correspondant trouvé
  606.             $user = $this->createUserWithCredentials(
  607.                 $email = null,
  608.                 $phone = null,
  609.                 $hashSMS = null,
  610.                 $uwandzaniToken = null,
  611.                 $facebookId = null,
  612.                 $googleId = null,
  613.                 $appleId = null,
  614.                 $isForFake = false,
  615.                 $userData = []
  616.             );
  617.             $user->setInstagramId($instagramId);
  618.             $this->em->flush();
  619.         }
  621.         return new JsonResponse([
  622.             'message' => 'Utilisateur Instagram créé avec succès',
  623.             'uuid' => $user->getUuid(),
  624.         ], 201);
  625.     }
  627.     /**********************************
  628.      * Créer un utilisateur avec un 
  629.      * ID TikTok
  630.      *********************************/
  632.     /**
  633.      * @Route("/pu/s/u/create-user/tiktok", name="api_create_user_with_tiktok", methods={"POST"})
  634.      */
  635.     public function createUserWithTikTok(Request $request, UserRepository $userRepository, ClientRegistry $clientRegistry): Response
  636.     {
  637.         if ($request->get('_route') === 'api_create_fake_users_with_tiktok') {
  638.             $fakeUsers = $userRepository->findBy(['isForFake' => true]);
  639.             if ($fakeUsers) {
  640.                 return $this->redirectToRoute(
  641.                     'app_security_user_delete_fake_users',
  642.                     ["nextRoute" => "api_create_fake_users_with_tiktok"]
  643.                 );
  644.             }
  646.             $userFakes = $this->fakeData->getUserFakeData();
  647.             $createdUsers = $this->createFakeUsersWithTikTok($userFakes);
  649.             return new JsonResponse([
  650.                 'message' => count($createdUsers) . ' utilisateurs fictifs créés avec succès.',
  651.                 'created_users' => $createdUsers,
  652.             ], 201);
  653.         }
  655.         $client = $clientRegistry->getClient('tiktok');
  656.         $userInfo = $client->fetchUser();
  658.         $tiktokId = $userInfo->getId();
  659.         $user = $userRepository->findOneBy(['tiktokId' => $tiktokId]);
  661.         if (!$user) {
  662.             // Créer un nouvel utilisateur si aucun utilisateur correspondant trouvé
  663.             $user = $this->createUserWithCredentials(
  664.                 $email = null,
  665.                 $phone = null,
  666.                 $hashSMS = null,
  667.                 $uwandzaniToken = null,
  668.                 $facebookId = null,
  669.                 $googleId = null,
  670.                 $appleId = null,
  671.                 $isForFake = false,
  672.                 $userData = []
  673.             );
  675.             $user->setTiktokId($tiktokId);
  676.             $this->em->flush();
  677.         }
  679.         return new JsonResponse([
  680.             'message' => 'Utilisateur TikTok créé avec succès',
  681.             'uuid' => $user->getUuid(),
  682.         ], 201);
  683.     }
  686.     /**
  687.      * @Route("/pu/s/u/reset-password", name="api_user_reset_password", methods={"POST"})
  688.      */
  689.     public function resetPassword(Request $request, UserRepository $userRepository): JsonResponse
  690.     {
  691.         $data = json_decode($request->getContent(), true);
  692.         $email = $data['email'] ?? null;
  694.         if (!$email) {
  695.             return new JsonResponse(['message' => 'Email est obligatoire.'], 400);
  696.         }
  698.         $user = $userRepository->findOneBy(['email' => $email]);
  699.         if (!$user) {
  700.             return new JsonResponse(['message' => 'Utilisateur introuvable.'], 404);
  701.         }
  703.         // Générez et envoyez un token pour réinitialiser le mot de passe ici
  704.         // Par exemple, vous pouvez envoyer un lien avec un token via email
  706.         return new JsonResponse(['message' => 'Lien de réinitialisation envoyé.']);
  707.     }
  709.     /**
  710.      * @Route("/api/pr/s/u/change-phone", name="api_user_change_phone", methods={"POST"})
  711.      */
  712.     public function changePhone(Request $request, UserRepository $userRepository): JsonResponse
  713.     {
  714.         $data = json_decode($request->getContent(), true);
  716.         /** @var User $user */
  717.         $user = $this->getUser();
  718.         $newPhone = $data['newPhone'] ?? null;
  720.         if (!$user || !$newPhone) {
  721.             return new JsonResponse(['message' => 'Tous les champs sont obligatoires.'], 400);
  722.         }
  724.         $existingUser = $userRepository->findOneBy(['phone' => $newPhone]);
  725.         if ($existingUser) {
  726.             return new JsonResponse(['message' => 'Ce numéro de téléphone est déjà utilisé.'], 400);
  727.         }
  729.         $user->setPhone($newPhone);
  730.         $this->em->flush();
  732.         return new JsonResponse(['message' => 'Numéro de téléphone changé avec succès.']);
  733.     }
  735.     /**
  736.      * @Route("/api/pr/s/u/change-email", name="api_user_change_email", methods={"POST"})
  737.      */
  738.     public function changeEmail(Request $request, UserRepository $userRepository): JsonResponse
  739.     {
  740.         $data = json_decode($request->getContent(), true);
  742.         /** @var User $user */
  743.         $user = $this->getUser();
  744.         $newEmail = $data['newEmail'] ?? null;
  746.         if (!$user || !$newEmail) {
  747.             return new JsonResponse(['message' => 'Tous les champs sont obligatoires.'], 400);
  748.         }
  750.         $existingUser = $userRepository->findOneBy(['email' => $newEmail]);
  751.         if ($existingUser) {
  752.             return new JsonResponse(['message' => 'Cet email est déjà utilisé.'], 400);
  753.         }
  755.         $user->setEmail($newEmail);
  756.         $this->em->flush();
  758.         return new JsonResponse(['message' => 'Email changé avec succès.']);
  759.     }
  762.     /**
  763.      * ***************************
  764.      *  Web : Affiche la page de demande de lien + envoie le lien si POST
  765.      * ***************************
  766.      * @Route("/app/pr/s/u/send-link-to-change-password", name="app_user_send_link_to_change_password", methods={"POST", "GET"})
  767.      *
  768.      * ***************************
  769.      *  API : Envoie un lien pour réinitialiser le mot de passe
  770.      * ***************************
  771.      * @Route("/api/pr/s/u/send-link-to-change-password", name="api_user_send_link_to_change_password", methods={"POST"})
  772.      */
  773.     public function sendLinkToChangePassword(UserRepository $userRepository, Request $request): Response
  774.     {
  775.         $route = $request->get('_route');
  777.         // Récupération de l'email selon la route
  778.         if ($route === 'api_user_send_link_to_change_password') {
  779.             $data = json_decode($request->getContent(), true);
  780.             $email = $data['email'] ?? null;
  781.         } else {
  782.             $email = $request->request->get('email');
  783.         }
  785.         $user = $email ? $userRepository->findOneBy(['email' => $email]) : null;
  787.         if (!$user) {
  788.             if ($route === 'api_user_send_link_to_change_password') {
  789.                 return new JsonResponse(['message' => 'Utilisateur introuvable.'], 404);
  790.             } else {
  791.                 $this->addFlash('error', 'Utilisateur introuvable.');
  792.                 return $this->render('security/lost_pw.html.twig');
  793.             }
  794.         }
  796.         // Cas de la version Web
  797.         if ($route === 'app_user_send_link_to_change_password') {
  798.             if ($request->getMethod() === "POST") {
  800.                 $user->setConfirmationToken(); // Génère un token aléatoire
  801.                 //$this->notificationMailService->envoieLienRappelMp($user); // Envoi du mail
  802.                 $this->em->flush();
  804.                 $this->addFlash('success', 'Un lien de récupération vous a été envoyé par mail.');
  805.                 return $this->redirectToRoute('home');
  806.             } else {
  807.                 return $this->render('security/lost_pw.html.twig');
  808.             }
  809.         }
  811.         // Cas API
  812.         $user->setConfirmationToken();
  813.         // $this->notificationMailService->envoieLienRappelMp($user);
  814.         $this->em->flush();
  816.         return new JsonResponse(['message' => 'Lien de réinitialisation envoyé.']);
  817.     }
  820.     /**
  821.      * @Route("/api/pr/s/u/change-password", name="api_user_change_password", methods={"POST"})
  822.      */
  823.     public function changePassword(Request $request, UserRepository $userRepository, UserPasswordHasherInterface $passwordHasher): JsonResponse
  824.     {
  825.         $data = json_decode($request->getContent(), true);
  827.         /** @var User $user */
  828.         $user = $this->getUser();
  829.         $oldPassword = $data['oldPassword'] ?? null;
  830.         $newPassword = $data['newPassword'] ?? null;
  832.         if (!$user || !$oldPassword || !$newPassword) {
  833.             return new JsonResponse(['message' => 'Tous les champs sont obligatoires.'], 400);
  834.         }
  836.         if (!$passwordHasher->isPasswordValid($user, $oldPassword)) {
  837.             return new JsonResponse(['message' => 'Ancien mot de passe incorrect.'], 401);
  838.         }
  840.         $hashedPassword = $passwordHasher->hashPassword($user, $newPassword);
  841.         $user->setPassword($hashedPassword);
  842.         $this->em->flush();
  844.         //$this->notificationMailService->envoieLienRappelMp($user);
  846.         return new JsonResponse(['message' => 'Mot de passe changé avec succès.']);
  847.     }
  849.     /**
  850.      * @Route("/api/delete-my-user", name="delete_my_user", methods={"GET"})
  851.      */
  852.     function deleteUser()
  853.     {
  854.         /**
  855.          * @var User $currentUser
  856.          */
  857.         $currentUser = $this->getUser();
  858.         // Ici je vais mettre toute la gestion de l'utilisateur supprimé
  860.         $this->securityService->deleteUser($currentUser);
  861.         $authToken = $this->securityService->createAndUpdateJwtToken($this->getUser());
  862.         return new JsonResponse(['token' => $authToken]);
  863.         //return new JsonResponse("Utilisateur supprimée");
  864.     }
  867.     ////////////////////////////////////// Fakes User //////////////////////////////////////
  869.     /******************************
  870.      * Créer des utilisateurs fictifs
  871.      * avec des emails
  872.      *****************************/
  874.     /**
  875.      * @Route("/pu/fake-users/email", name="api_create_fake_users_with_email", methods={"GET"})
  876.      */
  877.     public function createFakeUserWithEmail(Request $request, UserRepository $userRepository): Response
  878.     {
  880.         /***
  881.          * Vide les fake users avant de créer de nouveaux utilisateurs fictifs
  882.          * pour éviter les doublons
  883.          */
  884.         $fakeUsers = $userRepository->findBy(['isForFake' => true]);
  885.         if ($fakeUsers) {
  886.             return $this->redirectToRoute(
  887.                 'app_security_user_delete_fake_users',
  888.                 ["nextRoute" => "api_create_fake_users_with_email"]
  889.             );
  890.         }
  892.         $userFakes = $this->fakeData->getUserFakeData();
  893.         $createdUsers = $this->createFakeUsersWithEmail($userFakes);
  895.         return new JsonResponse([
  896.             'message' => count($createdUsers) . ' utilisateurs fictifs créés avec succès.',
  897.             'created_users' => $createdUsers,
  898.         ], 201);
  899.     }
  903.     /******************************
  904.      * Créer des utilisateurs fictifs
  905.      * avec des numéros de téléphone
  906.      *****************************/
  907.     /**
  908.      * @Route("/pu/fake-users/phone", name="api_create_fake_users_with_phone", methods={"GET"})
  909.      */
  910.     public function createFakeUserWithPhone(Request $request, UserRepository $userRepository): Response
  911.     {
  913.         $fakeUsers = $userRepository->findBy(['isForFake' => true]);
  914.         if ($fakeUsers) {
  915.             return $this->redirectToRoute(
  916.                 'app_security_user_delete_fake_users',
  917.                 [
  918.                     "nextRoute" => "api_create_fake_users_with_phone"
  919.                 ]
  920.             );
  921.         }
  923.         $userFakes = $this->fakeData->getUserFakeData();
  925.         $createdUsers = $this->createFakeUsersWithPhone($userFakes);
  927.         return new JsonResponse([
  928.             'message' => count($createdUsers) . ' utilisateurs fictifs créés avec succès.',
  929.             'created_users' => $createdUsers,
  930.         ], 201);
  931.     }
  935.     /******************************
  936.      * Créer des utilisateurs fictifs
  937.      * avec des ID Uwandzani
  938.      *****************************/
  939.     /**
  940.      * @Route("/pu/fake-users/uwandzani", name="api_create_fake_users_with_uwandzani", methods={"GET"})
  941.      */
  942.     public function createFakeUserWithUwandzani(Request $request, UserRepository $userRepository): Response
  943.     {
  944.         if ($request->get('_route') === 'api_create_fake_users_with_uwandzani') {
  945.             $fakeUsers = $userRepository->findBy(['isForFake' => true]);
  946.             if ($fakeUsers) {
  947.                 return $this->redirectToRoute(
  948.                     'app_security_user_delete_fake_users',
  949.                     [
  950.                         "nextRoute" => "api_create_fake_users_with_uwandzani"
  951.                     ]
  952.                 );
  953.             }
  955.             $userFakes = $this->fakeData->getUserFakeData();
  956.             $createdUsers = $this->createFakeUsersWithUwandzani($userFakes);
  958.             return new JsonResponse([
  959.                 'message' => count($createdUsers) . ' utilisateurs fictifs créés avec succès.',
  960.                 'created_users' => $createdUsers,
  961.             ], 201);
  962.         }
  964.         $data = json_decode($request->getContent(), true);
  965.         $uwandzaniToken = $data['uwandzaniToken'] ?? null;
  967.         $userData = null;
  971.         $user = $this->createUserWithCredentials(
  972.             $email = null,
  973.             $phone = null,
  974.             $hashSMS = null,
  975.             $uwandzaniToken,
  976.             $facebookId = null,
  977.             $googleId = null,
  978.             $appleId = null,
  979.             $isForFake = false,
  980.             $userData = []
  981.         );
  982.         if ($user instanceof JsonResponse) {
  983.             return $user;
  984.         }
  986.         return new JsonResponse(['message' => 'Utilisateur créé avec succès', 'uuid' => $user->getUuid()], 201);
  987.     }
  990.     /******************************
  991.      * Créer des utilisateurs fictifs
  992.      * avec des ID Facebook
  993.      *****************************/
  994.     /**
  995.      * @Route("/pu/s/u/create-user/facebook", name="api_create_user_with_facebook", methods={"POST"})
  996.      * @Route("/pu/fake-users/facebook", name="api_create_fake_users_with_facebook", methods={"GET"})
  997.      */
  998.     public function createFakeUserWithFacebook(Request $request, UserRepository $userRepository, ClientRegistry $clientRegistry): Response
  999.     {
  1000.         if ($request->get('_route') === 'api_create_fake_users_with_facebook') {
  1001.             $fakeUsers = $userRepository->findBy(['isForFake' => true]);
  1002.             if ($fakeUsers) {
  1003.                 return $this->redirectToRoute(
  1004.                     'app_security_user_delete_fake_users',
  1005.                     ["nextRoute" => "api_create_fake_users_with_facebook"]
  1006.                 );
  1007.             }
  1009.             $userFakes = $this->fakeData->getUserFakeData();
  1010.             $createdUsers = $this->createFakeUsersWithFacebook($userFakes);
  1012.             return new JsonResponse([
  1013.                 'message' => count($createdUsers) . ' utilisateurs fictifs créés avec succès.',
  1014.                 'created_users' => $createdUsers,
  1015.             ], 201);
  1016.         }
  1018.         $client = $clientRegistry->getClient('facebook');
  1019.         $userInfo = $client->fetchUser();
  1021.         // On vérifie si l'utilisateur existe déjà
  1022.         $facebookId = $userInfo->getId();
  1023.         $user = $userRepository->findOneBy(['facebookId' => $facebookId]);
  1025.         if (!$user) {
  1026.             // Créer un nouvel utilisateur si aucun utilisateur correspondant trouvé
  1027.             $user = $this->createUserWithCredentials(
  1028.                 $email = null,
  1029.                 $phone = null,
  1030.                 $hashSMS = null,
  1031.                 $uwandzaniToken = null,
  1032.                 $facebookId,
  1033.                 $googleId = null,
  1034.                 $appleId = null,
  1035.                 $isForFake = false,
  1036.                 $userData = []
  1037.             );
  1038.         }
  1040.         return new JsonResponse([
  1041.             'message' => 'Utilisateur Facebook créé avec succès',
  1042.             'uuid' => $user->getUuid(),
  1043.         ], 201);
  1044.     }
  1047.     /******************************
  1048.      * Créer des utilisateurs fictifs
  1049.      * avec des ID Google
  1050.      *****************************/
  1051.     /**
  1052.      * @Route("/pu/s/u/create-user/google", name="api_create_user_with_google", methods={"POST"})
  1053.      * @Route("/pu/fake-users/google", name="api_create_fake_users_with_google", methods={"GET"})
  1054.      */
  1055.     public function createFakeUserWithGoogle(Request $request, UserRepository $userRepository, ClientRegistry $clientRegistry): Response
  1056.     {
  1057.         if ($request->get('_route') === 'api_create_fake_users_with_google') {
  1058.             $fakeUsers = $userRepository->findBy(['isForFake' => true]);
  1059.             if ($fakeUsers) {
  1060.                 return $this->redirectToRoute(
  1061.                     'app_security_user_delete_fake_users',
  1062.                     ["nextRoute" => "api_create_fake_users_with_google"]
  1063.                 );
  1064.             }
  1066.             $userFakes = $this->fakeData->getUserFakeData();
  1067.             $createdUsers = $this->createFakeUsersWithGoogle($userFakes);
  1069.             return new JsonResponse([
  1070.                 'message' => count($createdUsers) . ' utilisateurs fictifs créés avec succès.',
  1071.                 'created_users' => $createdUsers,
  1072.             ], 201);
  1073.         }
  1075.         $client = $clientRegistry->getClient('google');
  1076.         $userInfo = $client->fetchUser();
  1078.         $googleId = $userInfo->getId();
  1079.         $user = $userRepository->findOneBy(['googleId' => $googleId]);
  1081.         if (!$user) {
  1082.             $user = $this->createUserWithCredentials(
  1083.                 $email = null,
  1084.                 $phone = null,
  1085.                 $hashSMS = null,
  1086.                 $uwandzaniToken = null,
  1087.                 $facebookId = null,
  1088.                 $googleId,
  1089.                 $appleId = null,
  1090.                 $isForFake = false,
  1091.                 $userData = []
  1092.             );
  1093.         }
  1095.         return new JsonResponse([
  1096.             'message' => 'Utilisateur Google créé avec succès',
  1097.             'uuid' => $user->getUuid(),
  1098.         ], 201);
  1099.     }
  1101.     /******************************
  1102.      * Créer des utilisateurs fictifs
  1103.      * avec des ID Apple
  1104.      *****************************/
  1105.     /**
  1106.      * @Route("/pu/s/u/create-user/apple", name="api_create_user_with_apple", methods={"POST"})
  1107.      * @Route("/pu/fake-users/apple", name="api_create_fake_users_with_apple", methods={"GET"})
  1108.      */
  1109.     public function createFakeUserWithApple(Request $request, UserRepository $userRepository, ClientRegistry $clientRegistry): Response
  1110.     {
  1111.         if ($request->get('_route') === 'api_create_fake_users_with_apple') {
  1112.             $fakeUsers = $userRepository->findBy(['isForFake' => true]);
  1113.             if ($fakeUsers) {
  1114.                 return $this->redirectToRoute(
  1115.                     'app_security_user_delete_fake_users',
  1116.                     ["nextRoute" => "api_create_fake_users_with_apple"]
  1117.                 );
  1118.             }
  1120.             $userFakes = $this->fakeData->getUserFakeData();
  1121.             $createdUsers = $this->createFakeUsersWithApple($userFakes);
  1123.             return new JsonResponse([
  1124.                 'message' => count($createdUsers) . ' utilisateurs fictifs créés avec succès.',
  1125.                 'created_users' => $createdUsers,
  1126.             ], 201);
  1127.         }
  1129.         $client = $clientRegistry->getClient('apple');
  1130.         $userInfo = $client->fetchUser();
  1132.         $appleId = $userInfo->getId();
  1133.         $user = $userRepository->findOneBy(['appleId' => $appleId]);
  1135.         if (!$user) {
  1136.             // Créer un nouvel utilisateur si aucun utilisateur correspondant trouvé
  1137.             $user = $this->createUserWithCredentials(
  1138.                 $email = null,
  1139.                 $phone = null,
  1140.                 $hashSMS = null,
  1141.                 $uwandzaniToken = null,
  1142.                 $facebookId = null,
  1143.                 $googleId = null,
  1144.                 $appleId,
  1145.                 $isForFake = false,
  1146.                 $userData = []
  1147.             );
  1148.         }
  1150.         return new JsonResponse([
  1151.             'message' => 'Utilisateur Apple créé avec succès',
  1152.             'uuid' => $user->getUuid(),
  1153.         ], 201);
  1154.     }
  1157.     /******************************
  1158.      * Créer des utilisateurs fictifs
  1159.      * avec des ID Instagram
  1160.      *****************************/
  1161.     /**
  1162.      * @Route("/pu/s/u/create-user/instagram", name="api_create_user_with_instagram", methods={"POST"})
  1163.      * @Route("/pu/fake-users/instagram", name="api_create_fake_users_with_instagram", methods={"GET"})
  1164.      */
  1165.     public function createFakeUserWithInstagram(Request $request, UserRepository $userRepository, ClientRegistry $clientRegistry): Response
  1166.     {
  1167.         if ($request->get('_route') === 'api_create_fake_users_with_instagram') {
  1168.             $fakeUsers = $userRepository->findBy(['isForFake' => true]);
  1169.             if ($fakeUsers) {
  1170.                 return $this->redirectToRoute(
  1171.                     'app_security_user_delete_fake_users',
  1172.                     ["nextRoute" => "api_create_fake_users_with_instagram"]
  1173.                 );
  1174.             }
  1176.             $userFakes = $this->fakeData->getUserFakeData();
  1177.             $createdUsers = $this->createFakeUsersWithInstagram($userFakes);
  1179.             return new JsonResponse([
  1180.                 'message' => count($createdUsers) . ' utilisateurs fictifs créés avec succès.',
  1181.                 'created_users' => $createdUsers,
  1182.             ], 201);
  1183.         }
  1185.         $client = $clientRegistry->getClient('instagram');
  1186.         $userInfo = $client->fetchUser();
  1188.         $instagramId = $userInfo->getId();
  1189.         $user = $userRepository->findOneBy(['instagramId' => $instagramId]);
  1191.         if (!$user) {
  1192.             // Créer un nouvel utilisateur si aucun utilisateur correspondant trouvé
  1193.             $user = $this->createUserWithCredentials(
  1194.                 $email = null,
  1195.                 $phone = null,
  1196.                 $hashSMS = null,
  1197.                 $uwandzaniToken = null,
  1198.                 $facebookId = null,
  1199.                 $googleId = null,
  1200.                 $appleId = null,
  1201.                 $isForFake = false,
  1202.                 $userData = []
  1203.             );
  1204.             $user->setInstagramId($instagramId);
  1205.             $this->em->flush();
  1206.         }
  1208.         return new JsonResponse([
  1209.             'message' => 'Utilisateur Instagram créé avec succès',
  1210.             'uuid' => $user->getUuid(),
  1211.         ], 201);
  1212.     }
  1215.     /******************************
  1216.      * Créer des utilisateurs fictifs
  1217.      * avec des ID TikTok
  1218.      *****************************/
  1219.     /**
  1220.      * @Route("/pu/s/u/create-user/tiktok", name="api_create_user_with_tiktok", methods={"POST"})
  1221.      * @Route("/pu/fake-users/tiktok", name="api_create_fake_users_with_tiktok", methods={"GET"})
  1222.      */
  1223.     public function createFakeUserWithTikTok(Request $request, UserRepository $userRepository, ClientRegistry $clientRegistry): Response
  1224.     {
  1225.         if ($request->get('_route') === 'api_create_fake_users_with_tiktok') {
  1226.             $fakeUsers = $userRepository->findBy(['isForFake' => true]);
  1227.             if ($fakeUsers) {
  1228.                 return $this->redirectToRoute(
  1229.                     'app_security_user_delete_fake_users',
  1230.                     ["nextRoute" => "api_create_fake_users_with_tiktok"]
  1231.                 );
  1232.             }
  1234.             $userFakes = $this->fakeData->getUserFakeData();
  1235.             $createdUsers = $this->createFakeUsersWithTikTok($userFakes);
  1237.             return new JsonResponse([
  1238.                 'message' => count($createdUsers) . ' utilisateurs fictifs créés avec succès.',
  1239.                 'created_users' => $createdUsers,
  1240.             ], 201);
  1241.         }
  1243.         $client = $clientRegistry->getClient('tiktok');
  1244.         $userInfo = $client->fetchUser();
  1246.         $tiktokId = $userInfo->getId();
  1247.         $user = $userRepository->findOneBy(['tiktokId' => $tiktokId]);
  1249.         if (!$user) {
  1250.             // Créer un nouvel utilisateur si aucun utilisateur correspondant trouvé
  1251.             $user = $this->createUserWithCredentials(
  1252.                 $email = null,
  1253.                 $phone = null,
  1254.                 $hashSMS = null,
  1255.                 $uwandzaniToken = null,
  1256.                 $facebookId = null,
  1257.                 $googleId = null,
  1258.                 $appleId = null,
  1259.                 $isForFake = false,
  1260.                 $userData = []
  1261.             );
  1263.             $user->setTiktokId($tiktokId);
  1264.             $this->em->flush();
  1265.         }
  1267.         return new JsonResponse([
  1268.             'message' => 'Utilisateur TikTok créé avec succès',
  1269.             'uuid' => $user->getUuid(),
  1270.         ], 201);
  1271.     }
  1275.     //////////////////////////////////// Methodes privées ////////////////////////////////////
  1277.     /*******************
  1278.      * Créer un User avec Email
  1279.      *******************/
  1280.     private function createUserWithEmailForApi(string $email): Response
  1281.     {
  1283.         $user = $this->createUserWithCredentials(
  1284.             $email,
  1285.             $phone = null,
  1286.             $hashSMS = null,
  1287.             $uwandzaniToken = null,
  1288.             $facebookId = null,
  1289.             $googleId = null,
  1290.             $appleId = null,
  1291.             $isForFake = false,
  1292.             $userData = []
  1293.         );
  1296.         if ($user instanceof JsonResponse) {
  1297.             return $user;
  1298.         }
  1300.         return new JsonResponse(['message' => 'Utilisateur créé avec succès', 'uuid' => $user->getUuid()], 201);
  1301.     }
  1303.     /*******************
  1304.      * Créer un User avec Phone
  1305.      *******************/
  1306.     private function createUserWithPhoneForApi(string $phone, ?array $hashSMS): User
  1307.     {
  1309.         $user = $this->createUserWithCredentials(
  1310.             $email = null,
  1311.             $phone = $phone,
  1312.             $hashSMS = $hashSMS,
  1313.             $uwandzaniToken = null,
  1314.             $facebookId = null,
  1315.             $googleId = null,
  1316.             $appleId = null,
  1317.             $isForFake = false,
  1318.             $userData = []
  1319.         );
  1321.         return $user;
  1322.     }
  1324.     ////////////////////////// Réseaux socio //////////////////////////
  1326.     /**
  1327.      * @Route("/oauth/connect/{serviceName}", name="oauth_connect", methods={"GET"})
  1328.      */
  1329.     public function getOauthScreen(string $serviceName, ClientRegistry $clientRegistry): Response
  1330.     {
  1331.         if (!array_key_exists($serviceName, self::SCOPES)) {
  1332.             throw new \Exception('Service non pris en charge');
  1333.         }
  1335.         return $clientRegistry->getClient($serviceName)->redirect(
  1336.             self::SCOPES[$serviceName],
  1337.             [] // Ajoutez un tableau vide comme deuxième argument
  1338.         );
  1339.     }
  1340.     /**
  1341.      * @Route("/connect/google/check", name="connect_google_check", methods={"GET"})
  1342.      */
  1343.     public function connectGoogleCheck(): Response
  1344.     {
  1345.         // Cette méthode sera appelée après la redirection de l'utilisateur depuis Google
  1346.         // Vous pouvez ajouter votre logique de traitement ici
  1347.         return $this->redirectToRoute('home');
  1348.     }
  1351.     private function findUserByCredentials(string $identifier): ?User
  1352.     {
  1353.         $user = $this->userRepository->findOneBy(['phone' => $identifier]);
  1355.         if (!$user) {
  1356.             $user = $this->userRepository->findOneBy(['uwandzaniToken' => $identifier]);
  1357.         }
  1359.         if (!$user) {
  1360.             $user = $this->userRepository->findOneBy(['email' => $identifier]);
  1361.         }
  1363.         if (!$user) {
  1364.             $user = $this->userRepository->findOneBy(['facebookId' => $identifier]);
  1365.         }
  1367.         if (!$user) {
  1368.             $user = $this->userRepository->findOneBy(['googleId' => $identifier]);
  1369.         }
  1371.         if (!$user) {
  1372.             $user = $this->userRepository->findOneBy(['appleId' => $identifier]);
  1373.         }
  1375.         if (!$user) {
  1376.             $user = $this->userRepository->findOneBy(['instagramId' => $identifier]);
  1377.         }
  1378.         return $user;
  1379.     }
  1381.     private function createUser($identifierType, $identifier, $hashSMS): User
  1382.     {
  1383.         if ($identifierType === 'phone') {
  1384.             $newUser = $this->createUserWithPhoneForApi($identifier, $hashSMS);
  1385.         } elseif ($identifierType === 'email') {
  1386.             $newUser = $this->createUserWithEmailForApi($identifier);
  1388.             //$user->generateVerificationCode();
  1389.             // On Envoyer de validation de l'adresse email
  1391.         }
  1392.         // elseif ($identifierType === 'uwandzani') {
  1393.         //     $newUser = $this->createUserWithCredentials($identifier);
  1394.         // } elseif ($identifierType === 'facebook') {
  1395.         //     $newUser = $this->createUserWithCredentials($identifier);
  1396.         // } elseif ($identifierType === 'google') {
  1397.         //     $newUser = $this->createUserWithCredentials($identifier);
  1398.         // } elseif ($identifierType === 'apple') {
  1399.         //     $newUser = $this->createUserWithCredentials($identifier);
  1400.         // } elseif ($identifierType === 'instagram') {
  1401.         //     $newUser = $this->createUserWithCredentials($identifier);
  1402.         // }
  1404.         return $newUser;
  1405.     }
  1407.     private function generateVerificationCode(User $user, ?array $hashSMS, $identifierType)
  1408.     {
  1409.         if ($user->getPhone() && $identifierType === 'phone') {
  1410.             $user->generateVerificationCode();
  1411.             $this->em->flush();
  1412.             $message = "<#>Votre code de validation " . $_ENV['APP_NAME'] . " est : " . $user->getVerificationCode() . "\n" . $hashSMS[0];
  1413.             $this->smsGenerator->sendSms($user->getPhone(), $message);
  1414.         }
  1415.     }
  1418.     //////////////////////////////////////////////////// Méthodes privées /////////////////////////////////////////////////
  1421.     ////////////////////////// Méthode pour créer des utilisateurs //////////////////////////
  1423.     private function createUserWithCredentials(
  1424.         ?string $email,
  1425.         ?string $phone,
  1426.         ?array $hashSMS,
  1427.         ?string $uwandzaniToken,
  1428.         ?string $facebookId,
  1429.         ?string $googleId,
  1430.         ?string $appleId,
  1431.         bool $isForFake = false,
  1432.         array $userData = []
  1433.     ) {
  1434.         $user = new User();
  1435.         $user->setIsForFake($isForFake);
  1437.         if ($email) {
  1438.             $user = $this->setUserWithEmail($user, $email);
  1439.         } elseif ($phone) {
  1440.             $user = $this->setUserWithPhone($user, $phone, $hashSMS);
  1441.         } elseif ($uwandzaniToken) {
  1442.             $user = $this->setUserWithUwandzani($user, $uwandzaniToken);
  1443.         } elseif ($facebookId) {
  1444.             $user = $this->setUserWithFacebook($user, $facebookId);
  1445.         } elseif ($googleId) {
  1446.             $user = $this->setUserWithGoogle($user, $googleId);
  1447.         } elseif ($appleId) {
  1448.             $user = $this->setUserWithApple($user, $appleId);
  1449.         }
  1451.         if ($uwandzaniToken === null) {
  1452.             //$hashedPassword = $this->passwordHasher->hashPassword($user, $password);
  1453.             //$user->setPassword($hashedPassword);
  1454.             $user->setRoles(['ROLE_USER']);
  1455.         } else {
  1456.             $user
  1457.                 ->setUwandzaniToken($uwandzaniToken)
  1458.                 //->setPassword($password)
  1459.                 ->setEmail($userData['email'])
  1460.                 ->setPhone($userData['phone'])
  1461.                 ->setFacebookId($userData['facebookId'])
  1462.                 ->setGoogleId($userData['googleId'])
  1463.                 ->setAppleId($userData['appleId'])
  1464.                 ->setUwandzaniId($userData['uwandzaniId']);
  1465.         }
  1467.         $this->em->persist($user);
  1468.         $this->em->flush();
  1470.         return $user;
  1471.     }
  1473.     ////////////////////////// Méthodes pour chaque type d'authentification //////////////////////////
  1475.     private function setUserWithEmail(User $user, string $email)
  1476.     {
  1477.         $existingUser = $this->em->getRepository(User::class)->findOneBy(['email' => $email]);
  1478.         if ($existingUser) {
  1479.             return new JsonResponse(['message' => 'Un utilisateur existe déjà avec cet email.'], 400);
  1480.         }
  1482.         $user->setEmail($email);
  1483.         return $user;
  1484.     }
  1486.     private function setUserWithPhone(User $user, string $phone, ?array $hashSMS)
  1487.     {
  1488.         $existingUser = $this->em->getRepository(User::class)->findOneBy(['phone' => $phone]);
  1489.         if ($existingUser) {
  1490.             return new JsonResponse(['message' => 'Un utilisateur existe déjà avec ce numéro de téléphone.'], 400);
  1491.         }
  1493.         $user->setPhone($phone);
  1494.         $message = "<#>Votre code de validation " . $_ENV['APP_NAME'] . " est : " . $user->getVerificationCode() . "\n" . $hashSMS[0];
  1495.         $this->smsGenerator->sendSms($phone, $message);
  1496.         return $user;
  1497.     }
  1499.     private function setUserWithUwandzani(User $user, string $uwandzaniToken)
  1500.     {
  1501.         $existingUser = $this->em->getRepository(User::class)->findOneBy(['uwandzaniToken' => $uwandzaniToken]);
  1502.         if ($existingUser) {
  1503.             return new JsonResponse(['message' => 'Un utilisateur existe déjà avec ce token Uwandzani.'], 400);
  1504.         }
  1506.         $user->setUwandzaniToken($uwandzaniToken);
  1507.         return $user;
  1508.     }
  1510.     private function setUserWithFacebook(User $user, string $facebookId)
  1511.     {
  1512.         $existingUser = $this->em->getRepository(User::class)->findOneBy(['facebookId' => $facebookId]);
  1513.         if ($existingUser) {
  1514.             return new JsonResponse(['message' => 'Un utilisateur existe déjà avec ce Facebook ID.'], 400);
  1515.         }
  1517.         $user->setFacebookId($facebookId);
  1518.         return $user;
  1519.     }
  1521.     private function setUserWithGoogle(User $user, string $googleId)
  1522.     {
  1523.         $existingUser = $this->em->getRepository(User::class)->findOneBy(['googleId' => $googleId]);
  1524.         if ($existingUser) {
  1525.             return new JsonResponse(['message' => 'Un utilisateur existe déjà avec ce Google ID.'], 400);
  1526.         }
  1528.         $user->setGoogleId($googleId);
  1529.         return $user;
  1530.     }
  1532.     private function setUserWithApple(User $user, string $appleId)
  1533.     {
  1534.         $existingUser = $this->em->getRepository(User::class)->findOneBy(['appleId' => $appleId]);
  1535.         if ($existingUser) {
  1536.             return new JsonResponse(['message' => 'Un utilisateur existe déjà avec cet Apple ID.'], 400);
  1537.         }
  1539.         $user->setAppleId($appleId);
  1540.         return $user;
  1541.     }
  1543.     ////////////////////////// Suppression des utilisateurs fictifs //////////////////////////
  1545.     /**
  1546.      * @Route("/pr/s/u/delete-fake-users/{nextRoute}", name="app_security_user_delete_fake_users", methods={"GET"})
  1547.      */
  1548.     public function deleteFakeUsers(UserRepository $userRepository, string $nextRoute): Response
  1549.     {
  1550.         $fakeUsers = $userRepository->findBy(['isForFake' => true]);
  1552.         foreach ($fakeUsers as $fakeUser) {
  1553.             $this->em->remove($fakeUser);
  1554.             $this->em->flush();
  1555.         }
  1557.         return $this->redirectToRoute($nextRoute, [], Response::HTTP_SEE_OTHER);
  1558.     }
  1560.     ////////////////////////// Création d'utilisateurs fictifs pour chaque méthode //////////////////////////
  1562.     private function createFakeUsersWithEmail(array $fakeUsersData): array
  1563.     {
  1564.         $createdUsers = [];
  1565.         foreach ($fakeUsersData as $userData) {
  1566.             $result = $this->createUserWithCredentials(
  1567.                 $userData['email'],
  1568.                 null,
  1569.                 null,
  1570.                 null,
  1571.                 null,
  1572.                 null,
  1573.                 true
  1574.             );
  1575.             if ($result instanceof JsonResponse) {
  1576.                 continue;
  1577.             }
  1578.             $createdUsers[] = ['email' => $userData['email']];
  1579.         }
  1580.         return $createdUsers;
  1581.     }
  1583.     private function createFakeUsersWithPhone(array $fakeUsersData): array
  1584.     {
  1585.         $createdUsers = [];
  1586.         foreach ($fakeUsersData as $userData) {
  1588.             $result = $this->createUserWithCredentials(
  1589.                 null,
  1590.                 $userData['phone'],
  1591.                 null,
  1592.                 null,
  1593.                 null,
  1594.                 null,
  1595.                 true
  1596.             );
  1597.             if ($result instanceof JsonResponse) {
  1598.                 continue;
  1599.             }
  1600.             $createdUsers[] = ['phone' => $userData['phone']];
  1601.         }
  1602.         return $createdUsers;
  1603.     }
  1605.     private function createFakeUsersWithUwandzani(array $fakeUsersData): array
  1606.     {
  1607.         $createdUsers = [];
  1608.         foreach ($fakeUsersData as $userData) {
  1609.             $result = $this->createUserWithCredentials(
  1610.                 null,
  1611.                 null,
  1612.                 $userData['uwandzaniToken'],
  1613.                 null,
  1614.                 null,
  1615.                 null,
  1616.                 true
  1617.             );
  1618.             if ($result instanceof JsonResponse) {
  1619.                 continue;
  1620.             }
  1621.             $createdUsers[] = ['uwandzaniToken' => $userData['uwandzaniToken']];
  1622.         }
  1623.         return $createdUsers;
  1624.     }
  1626.     private function createFakeUsersWithFacebook(array $fakeUsersData): array
  1627.     {
  1628.         $createdUsers = [];
  1629.         foreach ($fakeUsersData as $userData) {
  1630.             $result = $this->createUserWithCredentials(
  1631.                 null,
  1632.                 null,
  1633.                 null,
  1634.                 $userData['facebookId'],
  1635.                 null,
  1636.                 null,
  1637.                 true
  1638.             );
  1639.             if ($result instanceof JsonResponse) {
  1640.                 continue;
  1641.             }
  1642.             $createdUsers[] = ['facebookId' => $userData['facebookId']];
  1643.         }
  1644.         return $createdUsers;
  1645.     }
  1647.     private function createFakeUsersWithGoogle(array $fakeUsersData): array
  1648.     {
  1649.         $createdUsers = [];
  1650.         foreach ($fakeUsersData as $userData) {
  1651.             $result = $this->createUserWithCredentials(
  1652.                 null,
  1653.                 null,
  1654.                 null,
  1655.                 null,
  1656.                 $userData['googleId'],
  1657.                 null,
  1658.                 true
  1659.             );
  1660.             if ($result instanceof JsonResponse) {
  1661.                 continue;
  1662.             }
  1663.             $createdUsers[] = ['googleId' => $userData['googleId']];
  1664.         }
  1665.         return $createdUsers;
  1666.     }
  1668.     private function createFakeUsersWithApple(array $fakeUsersData): array
  1669.     {
  1670.         $createdUsers = [];
  1671.         foreach ($fakeUsersData as $userData) {
  1672.             $result = $this->createUserWithCredentials(
  1673.                 null,
  1674.                 null,
  1675.                 null,
  1676.                 null,
  1677.                 null,
  1678.                 $userData['appleId'],
  1679.                 true
  1680.             );
  1681.             if ($result instanceof JsonResponse) {
  1682.                 continue;
  1683.             }
  1684.             $createdUsers[] = ['appleId' => $userData['appleId']];
  1685.         }
  1686.         return $createdUsers;
  1687.     }
  1689.     private function createFakeUsersWithTikTok(array $fakeUsersData): array
  1690.     {
  1691.         $createdUsers = [];
  1692.         foreach ($fakeUsersData as $userData) {
  1693.             $result = $this->createUserWithCredentials(
  1694.                 null,
  1695.                 null,
  1696.                 null,
  1697.                 null,
  1698.                 null,
  1699.                 null,
  1700.                 true
  1701.             );
  1703.             if ($result instanceof JsonResponse) {
  1704.                 continue;
  1705.             }
  1707.             // Ajouter l'ID TikTok pour l'utilisateur fictif
  1708.             $result->setTiktokId($userData['tiktokId']);
  1709.             $this->em->persist($result);
  1710.             $this->em->flush();
  1712.             $createdUsers[] = ['tiktokId' => $userData['tiktokId']];
  1713.         }
  1715.         return $createdUsers;
  1716.     }
  1718.     private function createFakeUsersWithInstagram(array $fakeUsersData): array
  1719.     {
  1720.         $createdUsers = [];
  1721.         foreach ($fakeUsersData as $userData) {
  1722.             $result = $this->createUserWithCredentials(
  1723.                 null,
  1724.                 null,
  1725.                 null,
  1726.                 null,
  1727.                 null,
  1728.                 null,
  1729.                 true
  1730.             );
  1732.             if ($result instanceof JsonResponse) {
  1733.                 continue;
  1734.             }
  1736.             // Ajouter l'ID Instagram pour l'utilisateur fictif
  1737.             $result->setInstagramId($userData['instagramId']);
  1738.             $this->em->persist($result);
  1739.             $this->em->flush();
  1741.             $createdUsers[] = ['instagramId' => $userData['instagramId']];
  1742.         }
  1744.         return $createdUsers;
  1745.     }
  1746. }