src/Controller/UserController.php line 307

  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\Formation;
  6. use App\Entity\Trainee;
  7. use App\Entity\TraineeFormation;
  8. use App\Entity\User;
  9. use App\Form\RegistrationFormType;
  10. use App\Form\TraineeFormType;
  11. use App\Form\UpdateUserFormType;
  12. use Doctrine\DBAL\Types\TextType;
  13. use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
  14. use PhpOffice\PhpSpreadsheet\Spreadsheet;
  15. use PhpOffice\PhpSpreadsheet\Writer\Xls;
  16. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  17. use Symfony\Component\HttpFoundation\File\UploadedFile;
  18. use Symfony\Component\HttpFoundation\Request;
  19. use Symfony\Component\HttpFoundation\Response;
  20. use Symfony\Component\HttpFoundation\StreamedResponse;
  21. use Symfony\Component\Mailer\MailerInterface;
  22. use Symfony\Component\Mime\Email;
  23. use Symfony\Component\Routing\Annotation\Route;
  24. use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
  25. use Symfony\Component\Security\Core\Security;
  26. use Symfony\Component\Security\Http\Authentication\UserAuthenticatorInterface;
  27. use App\Security\AppAuthenticator;
  28. use Doctrine\ORM\EntityManagerInterface;
  30. class UserController extends AbstractController
  31. {
  32.     /** User CRUD */
  33.     #[Route('/user', name: 'app_user')]
  34.     public function index(EntityManagerInterface $entityManager): Response
  35.     {
  36.         $users = $entityManager->getRepository(User::class)->findUsers("ROLE_SUPER_ADMIN");
  37.         return $this->render('user/index.html.twig', [
  38.             'users' => $users,
  39.         ]);
  40.     }
  42.     #[Route('/user/add', name: 'app_add_user')]
  43.     public function addUser(Request $request, UserPasswordHasherInterface $userPasswordHasher, UserAuthenticatorInterface $userAuthenticator, EntityManagerInterface $entityManager): Response
  44.     {
  45.         $user = new User();
  46.         $form = $this->createForm(RegistrationFormType::class, $user);
  47.         $form->handleRequest($request);
  48.         if ($form->isSubmitted() && $form->isValid()) {
  49.              // Créer une instance de l'entité User avec les données du formulaire
  50.             $user = $form->getData();
  52.             // Définir le rôle de l'utilisateur en tant qu'utilisateur
  53.             $user->setRoles(['ROLE_SUPER_ADMIN']);
  54.             // encode the plain password
  55.             $user->setPassword(
  56.                 $userPasswordHasher->hashPassword(
  57.                     $user,
  58.                     $form->get('password')->getData()
  59.                 )
  60.             );
  61.             $entityManager->persist($user);
  62.             $entityManager->flush();
  63.             // do anything else you need here, like send an email
  64.             return $this->redirectToRoute('app_user');
  65.         }
  66.         return $this->render('user/new.html.twig', [
  67.             'registrationForm' => $form->createView(),
  68.         ]);
  69.     }
  71.     #[Route('/user/profile/{id}', name: 'app_edit_user')]
  72.     public function updateUserProfile(Request $request, EntityManagerInterface $entityManager, $id): Response
  73.     {
  74.         if($id) {
  75.             $user = $entityManager->getRepository(User::class)->findOneBy(['id' => $id]);
  76.         } else {
  77.             $user = $this->getUser();
  78.         }
  79.         $form = $this->createForm(UpdateUserFormType::class, $user);
  80.         $form->handleRequest($request);
  81.         $teacher = false;
  82.         if (in_array('ROLE_TEACHER', $this->getUser()->getRoles(), true)) {
  83.             $teacher = true;
  84.         }
  85.         if ($form->isSubmitted() && $form->isValid()) {
  86.             $user = $form->getData();
  88.             if ($teacher) {
  89.                 $signatureMode = (string) $request->request->get('signature_mode', 'draw');
  90.                 $uploadedSignature = $request->files->get('signature_upload');
  92.                 if ($signatureMode === 'upload' && $uploadedSignature instanceof UploadedFile) {
  93.                     $allowedMimeTypes = ['image/png', 'image/jpeg', 'image/jpg', 'image/webp'];
  94.                     $mimeType = (string) $uploadedSignature->getMimeType();
  96.                     if (in_array($mimeType, $allowedMimeTypes, true) && $uploadedSignature->getSize() <= 5 * 1024 * 1024) {
  97.                         $binary = file_get_contents($uploadedSignature->getRealPath());
  98.                         if ($binary !== false) {
  99.                             $sourceImage = @imagecreatefromstring($binary);
  100.                             if ($sourceImage !== false) {
  101.                                 $targetWidth = 150;
  102.                                 $targetHeight = 150;
  104.                                 $resizedImage = imagecreatetruecolor($targetWidth, $targetHeight);
  105.                                 imagealphablending($resizedImage, false);
  106.                                 imagesavealpha($resizedImage, true);
  107.                                 $transparent = imagecolorallocatealpha($resizedImage, 0, 0, 0, 127);
  108.                                 imagefilledrectangle($resizedImage, 0, 0, $targetWidth, $targetHeight, $transparent);
  110.                                 imagecopyresampled(
  111.                                     $resizedImage,
  112.                                     $sourceImage,
  113.                                     0,
  114.                                     0,
  115.                                     0,
  116.                                     0,
  117.                                     $targetWidth,
  118.                                     $targetHeight,
  119.                                     imagesx($sourceImage),
  120.                                     imagesy($sourceImage)
  121.                                 );
  123.                                 ob_start();
  124.                                 $outputMimeType = $mimeType === 'image/jpg' ? 'image/jpeg' : $mimeType;
  125.                                 if ($outputMimeType === 'image/png') {
  126.                                     imagepng($resizedImage);
  127.                                 } elseif ($outputMimeType === 'image/webp' && function_exists('imagewebp')) {
  128.                                     imagewebp($resizedImage, null, 90);
  129.                                 } else {
  130.                                     $outputMimeType = 'image/jpeg';
  131.                                     imagejpeg($resizedImage, null, 90);
  132.                                 }
  133.                                 $resizedBinary = ob_get_clean();
  135.                                 imagedestroy($sourceImage);
  136.                                 imagedestroy($resizedImage);
  138.                                 if ($resizedBinary !== false) {
  139.                                     $user->setSignature('data:' . $outputMimeType . ';base64,' . base64_encode($resizedBinary));
  140.                                 } else {
  141.                                     $user->setSignature('data:' . $mimeType . ';base64,' . base64_encode($binary));
  142.                                 }
  143.                             } else {
  144.                                 $user->setSignature('data:' . $mimeType . ';base64,' . base64_encode($binary));
  145.                             }
  146.                         }
  147.                     }
  148.                 }
  149.             }
  151.             $entityManager->persist($user);
  152.             $entityManager->flush();
  153.             // Stay on the same profile page after save and refresh state.
  154.             return $this->redirectToRoute('app_edit_user', ['id' => $user->getId()]);
  155.         }
  156.         return $this->render('user/update.html.twig', [
  157.             'setUserForm' => $form->createView(),
  158.             'teacher' => $teacher
  159.         ]);
  160.     }
  161.     /** Trainees CRUD */
  162.     #[Route('/user/trainees', name: 'app_trainees')]
  163.     public function listOfTrainees(EntityManagerInterface $entityManager): Response
  164.     {
  165.         $isTeacher = false;
  166.         if (in_array('ROLE_TEACHER', $this->getUser()->getRoles(), true)) {
  167.             $isTeacher = true;
  168.         }
  170.         if ($isTeacher) {
  171.             $users = $entityManager->createQueryBuilder()
  172.                 ->select('DISTINCT t')
  173.                 ->from(Trainee::class, 't')
  174.                 ->innerJoin(TraineeFormation::class, 'tf', 'WITH', 'tf.trainee = t')
  175.                 ->innerJoin('tf.formation', 'f')
  176.                 ->where('f.formateur = :teacher')
  177.                 ->setParameter('teacher', $this->getUser())
  178.                 ->orderBy('t.id', 'DESC')
  179.                 ->getQuery()
  180.                 ->getResult();
  181.         } else {
  182.             $users = $entityManager->getRepository(Trainee::class)->findBy([], ['id' => 'DESC']);
  183.         }
  185.         return $this->render('trainees/trainees.html.twig', [
  186.             'users' => $users,
  187.             'base_template' => $isTeacher ? 'baseTeacher.html.twig' : 'baseAdmin.html.twig'
  188.         ]);
  189.     }
  191.     #[Route('/user/addTrainee/{formationId}', name: 'app_add_trainee')]
  192.     public function addTrainees(Request $request, EntityManagerInterface $entityManager, $formationId = null): Response
  193.     {
  194.         $user = new Trainee();
  195.         $type = "";
  196.         $formation = null;
  197.         if ($formationId) {
  198.             $formation = $entityManager->getRepository(Formation::class)->findOneBy(['id' => $formationId]);
  199.             if ($formation) {
  200.                 $type = $formation->getType();
  201.                 if( $formation->getType() == "intra") {
  202.                     $customer = $formation->getCustomers();
  203.                     if ($customer) {
  204.                         $user->setCustomer($customer[0]);
  205.                     }
  206.                 }  
  207.             }
  208.         }
  209.         // hide comments field on the trainee edit view
  210.         $form = $this->createForm(TraineeFormType::class, $user, ['show_comments' => false]);
  211.         $form->handleRequest($request);
  212.         if ($form->isSubmitted() && $form->isValid()) {
  213.             $user = $form->getData();
  214.             $entityManager->persist($user);
  215.             $entityManager->flush();
  216.             if($formationId) {
  217.                 $formation  = $entityManager->getRepository(Formation::class)->findOneBy(['id'=> $formationId]);
  218.                 $TraineeFormation = new TraineeFormation();
  219.                 $TraineeFormation->setTrainee($user);
  220.                 $TraineeFormation->setFormation($formation);
  221.                 $entityManager->persist($TraineeFormation);
  222.                 $entityManager->flush();
  223.                 return $this->redirectToRoute('app_courses_manage', ['idFormation' => $formationId, 'type' => $formation->getType()]);
  224.             } else {
  225.                 return $this->redirectToRoute('app_trainees');
  226.             }
  227.         }
  228.         $isTeacher = false;
  229.         if (in_array('ROLE_TEACHER', $this->getUser()->getRoles(), true)) {
  230.             $isTeacher = true;
  231.         }
  232.         return $this->render('trainees/new_trainee.html.twig', [
  233.             'registrationForm' => $form->createView(),
  234.             'formationId' => $formationId,
  235.             'typeFormation' => $type,
  236.             'base_template' => $isTeacher ? 'baseTeacher.html.twig' : 'baseAdmin.html.twig'
  237.         ]);
  238.     }
  239.     /** Teacher CRUD */
  240.     #[Route('/user/teachers', name: 'app_teachers')]
  241.     public function listOfTeacher(EntityManagerInterface $entityManager): Response
  242.     {
  243.         $users = $entityManager->getRepository(User::class)->findUsers('ROLE_TEACHER');
  244.         return $this->render('user/teachers.html.twig', [
  245.             'users' => $users,
  246.         ]);
  247.     }
  249.     #[Route('/user/addTeacher', name: 'app_add_teacher')]
  250.     public function addTeacher(Request $request, EntityManagerInterface $entityManager, UserPasswordHasherInterface $userPasswordHasher): Response
  251.     {
  252.         $user = new User();
  253.         $form = $this->createForm(UpdateUserFormType::class, $user);
  254.         $form->handleRequest($request);
  255.         if ($form->isSubmitted() && $form->isValid()) {
  256.             $user = $form->getData();
  257.             //set default password for Trainees 00000000
  258.             $user->setPassword(
  259.                 $userPasswordHasher->hashPassword(
  260.                     $user,
  261.                     '00000000'
  262.                 )
  263.             );
  265.             $user->setRoles(['ROLE_TEACHER']);
  266.             $entityManager->persist($user);
  267.             $entityManager->flush();
  268.             return $this->redirectToRoute('app_teachers');
  269.         }
  270.         return $this->render('user/new_teacher.html.twig', [
  271.             'registrationForm' => $form->createView(),
  272.         ]);
  273.     }
  275.     #[Route('/trainee/edit/{id}/{idFormation}', name: 'app_edit_trainee')]
  276.     public function updateTrainee(Request $request, EntityManagerInterface $entityManager, $id, $idFormation = null): Response
  277.     {
  278.         $user = $entityManager->getRepository(Trainee::class)->findOneBy(['id' => $id]);
  279.         $form = $this->createForm(TraineeFormType::class, $user, ['show_comments' => false]);
  280.         $type = "";
  281.         if($idFormation) {
  282.             $formation = $entityManager->getRepository(Formation::class)->findOneBy(['id' => $idFormation]);
  283.             $type = $formation->getType();
  284.         }
  285.         $form->handleRequest($request);
  286.         if ($form->isSubmitted() && $form->isValid()) {
  287.             $user = $form->getData();
  288.             $entityManager->persist($user);
  289.             $entityManager->flush();
  290.             if ($idFormation !== null) {
  291.                 return $this->redirectToRoute('app_courses_manage', ['type' => $type, 'idFormation' => $idFormation]);
  292.             }
  293.             return $this->redirectToRoute('app_trainees');
  294.         }
  295.         $isTeacher = false;
  296.         if (in_array('ROLE_TEACHER', $this->getUser()->getRoles(), true)) {
  297.             $isTeacher = true;
  298.         }
  299.         return $this->render('trainees/update_trainee.html.twig', [
  300.             'setTraineeForm' => $form->createView(),
  301.             'typeFormation' => $type,
  302.             'base_template' => $isTeacher ? 'baseTeacher.html.twig' : 'baseAdmin.html.twig'
  303.         ]);
  304.     }
  306.     #[Route('/update-password', name: 'app_update_password')]
  307.     public function updatePassword(Request $request, EntityManagerInterface $entityManager, MailerInterface $mailer): Response
  308.     {
  309.         if ($request->isMethod('POST')) {
  310.             $email = $request->request->get('email');
  311.             if($email != "") {
  312.                 $user = $entityManager->getRepository(User::class)->findOneBy(['email' => $email]);
  313.                 if ($user) {
  314.                     //send mail to user with token
  315.                     $link = 'https://adformation.online'.$this->generateUrl('app_update_user_password',['email'=>$email]);
  316.                     $emailToSend = (new Email())
  317.                         ->from('noreply-formation@adconseil.eu')
  318.                         ->subject('Modification de mot de passe')
  319.                         ->html('<p>Bonjour, cliquer sur le lien pour modifier votre mot de passe:<br><a href="'.$link.'">'.$link.'</a></p>')
  320.                         ->to($user->getEmail());
  321.                     $mailer->send($emailToSend);
  322.                     $this->addFlash('success', "Un email est envoyé à votre compte.");
  323.                     return $this->redirectToRoute('app_update_password');
  324.                 } else {
  325.                     // show error message
  326.                     $this->addFlash('warning', "Cet email n'existe pas!");
  327.                     return $this->redirectToRoute('app_update_password');
  328.                 }
  329.             }
  330.             return $this->redirectToRoute('app_update_password');
  331.         }
  332.         return $this->render('security/resetPassword.html.twig', [
  333.         ]);
  334.     }
  336.     #[Route('/update-user-password/{email}', name: 'app_update_user_password')]
  337.     public function updateUserPassword(Request $request, EntityManagerInterface $entityManager,UserPasswordHasherInterface $userPasswordHasher, $email): Response
  338.     {
  339.         if ($request->isMethod('POST')) {
  340.             $password= $request->request->get('password');
  341.             if($email != "" && $password != "") {
  342.                 $user = $entityManager->getRepository(User::class)->findOneBy(['email' => $email]);
  343.                 if ($user) {
  344.                     //update password
  345.                     $user->setPassword(
  346.                         $userPasswordHasher->hashPassword(
  347.                             $user,
  348.                             $password
  349.                         )
  350.                     );
  351.                     $entityManager->persist($user);
  352.                     $entityManager->flush();
  353.                     $this->addFlash('success', "Votre mot de passe aura été changé avec succès");
  354.                     return $this->redirectToRoute('app_login');
  355.                 } else {
  356.                     // show error message
  357.                     $this->addFlash('warning', "Le lien est incorrect");
  358.                     return $this->redirectToRoute('app_update_user_password');
  359.                 }
  360.             }
  361.             return $this->redirectToRoute('app_login');
  362.         }
  363.         return $this->render('security/newPassword.html.twig', [
  364.         ]);
  365.     }
  366.     #[Route('/trainee/delete/{id}', name: 'app_delete_trainee')]
  367.     public function deleteTrainee(EntityManagerInterface $entityManager, $id): Response
  368.     {
  369.         $trainee = $entityManager->getRepository(Trainee::class)->findOneBy(['id' => $id]);
  370.         $traineeFormation = $entityManager->getRepository(TraineeFormation::class)->findBy(['trainee' => $trainee]);
  371.         //find if trainee is affected to formation
  372.         $object = new \stdClass();
  373.         if($traineeFormation) {
  374.             foreach ($traineeFormation as $trfor) {
  375.                  $entityManager->remove($trfor);
  376.             }
  377.             $entityManager->flush();
  378.         }
  380.         $entityManager->remove($trainee);
  381.         $entityManager->flush();
  382.         $object->status = true;
  383.         $object->message = "Le stagiaire est supprimé avec succès";
  384.         return new Response(json_encode($object));
  385.     }
  386.     #[Route('/teacher/delete/{id}', name: 'app_delete_teacher')]
  387.     public function deleteTeacher(EntityManagerInterface $entityManager, $id): Response
  388.     {
  389.         $teacher = $entityManager->getRepository(User::class)->findOneBy(['id' => $id]);
  390.         //find if trainee is affected to formation
  391.         $teacherFormation = $entityManager->getRepository(Formation::class)->findOneBy(['formateur' => $teacher]);
  392.         $object = new \stdClass();
  393.         if ($teacherFormation) {
  394.             $object->status = false;
  395.             $object->message = "Ce formateur est enregistré dans une formation et il est impossible de le supprimer.";
  396.         } else {
  397.             $entityManager->remove($teacher);
  398.             $entityManager->flush();
  399.             $object->status = true;
  400.             $object->message = "Le formateur est supprimé avec succès";
  401.         }
  402.         return new Response(json_encode($object));
  403.     }
  405.     #[Route('/user/delete/{id}', name: 'app_delete_user')]
  406.     public function deleteUser(EntityManagerInterface $entityManager, $id): Response
  407.     {
  408.         $user = $entityManager->getRepository(User::class)->findOneBy(['id' => $id]);
  409.         $object = new \stdClass();
  410.         $entityManager->remove($user);
  411.         $entityManager->flush();
  412.         $object->status = true;
  413.         $object->message = "L'utilisateur est supprimé avec succès";
  414.         return new Response(json_encode($object));
  415.     }
  417.     #[Route('/downloadTrainee', name: 'app_download_trainee')]
  418.     public function downloadTrainee(EntityManagerInterface $entityManager): Response
  419.     {
  420.         $users = $entityManager->getRepository(Trainee::class)->findBy([],['id' => 'DESC']);
  421.         $spreadsheet = new Spreadsheet();
  422.         $sheet = $spreadsheet->getActiveSheet();
  423.         $sheet->setCellValue('A1', 'Nom');
  424.         $sheet->setCellValue('B1', 'Prénom');
  425.         $sheet->setCellValue('C1', 'Fonction');
  426.         $sheet->setCellValue('D1', 'Email');
  427.         $counter = 2;
  428.         foreach ($users as $user) {
  429.             $sheet->setCellValue('A' . $counter, $user->getFirstName());
  430.             $sheet->setCellValue('B' . $counter, $user->getLastName());
  431.             $sheet->setCellValue('C' . $counter, $user->getPosition());
  432.             $sheet->setCellValue('D' . $counter, $user->getEmail());
  433.             $counter++;
  434.         }
  435.         $writer = new Xls($spreadsheet);
  436.         $response =  new StreamedResponse(
  437.             function () use ($writer) {
  438.                 $writer->save('php://output');
  439.             }
  440.         );
  441.         $fileName = "ExportEmails_".date('m-d-Y_hia').".xls";
  442.         $response->headers->set('Content-Type', 'application/vnd.ms-excel');
  443.         $response->headers->set('Content-Disposition', 'attachment; filename=' . '"' . $fileName . '"');
  444.         $response->headers->set('Cache-Control','max-age=0');
  445.         return $response;
  446.         //$this->addFlash('success', "Les stagiaires sont télechargées avec succès.");
  447.        // return $this->redirectToRoute('app_trainees');
  448.     }
  450.     #[Route('/downloadTraineeByFormation/{idFormation}', name: 'app_download_trainee_by_formation')]
  451.     public function downloadTraineeByFormation(EntityManagerInterface $entityManager, $idFormation = null): Response
  452.     {
  453.         $course =  $entityManager->getRepository(Formation::class)->find($idFormation);
  454.         $formationUser = $entityManager->getRepository(TraineeFormation::class)->findBy(['formation' => $course]);
  455.         $spreadsheet = new Spreadsheet();
  456.         $sheet = $spreadsheet->getActiveSheet();
  457.         $sheet->setCellValue('A1', 'Nom');
  458.         $sheet->setCellValue('B1', 'Prénom');
  459.         $sheet->setCellValue('C1', 'Fonction');
  460.         $sheet->setCellValue('D1', 'Email');
  461.         $counter = 2;
  462.         foreach ($formationUser as $item) {
  463.             $sheet->setCellValue('A' . $counter, $item->getTrainee()->getFirstName());
  464.             $sheet->setCellValue('B' . $counter, $item->getTrainee()->getLastName());
  465.             $sheet->setCellValue('C' . $counter, $item->getTrainee()->getPosition());
  466.             $sheet->setCellValue('D' . $counter, $item->getTrainee()->getEmail());
  467.             $counter++;
  468.         }
  469.         $writer = new Xls($spreadsheet);
  470.         $response =  new StreamedResponse(
  471.             function () use ($writer) {
  472.                 $writer->save('php://output');
  473.             }
  474.         );
  475.         $fileName = "ExportEmails_".str_replace(' ','',$course->getNomFormation())."_".date('m-d-Y_hia').".xls";
  476.         $response->headers->set('Content-Type', 'application/vnd.ms-excel');
  477.         $response->headers->set('Content-Disposition', 'attachment; filename=' . '"' . $fileName . '"');
  478.         $response->headers->set('Cache-Control','max-age=0');
  479.         return $response;
  480.         //$this->addFlash('success', "Les stagiaires sont télechargées avec succès.");
  481.         // return $this->redirectToRoute('app_trainees');
  482.     }
  484.     #[Route('/user/profileAdmin/{id}', name: 'app_edit_admin')]
  485.     public function updateAdminProfile(Request $request, EntityManagerInterface $entityManager, $id): Response
  486.     {
  487.         if($id) {
  488.             $user = $entityManager->getRepository(User::class)->findOneBy(['id' => $id]);
  489.         } else {
  490.             $user = $this->getUser();
  491.         }
  492.         $form = $this->createForm(UpdateUserFormType::class, $user);
  493.         $form->handleRequest($request);
  494.         $teacher = false;
  495.         if (in_array('ROLE_TEACHER', $this->getUser()->getRoles(), true)) {
  496.             $teacher = true;
  497.         }
  498.         if ($form->isSubmitted() && $form->isValid()) {
  499.             $user = $form->getData();
  500.             $entityManager->persist($user);
  501.             $entityManager->flush();
  502.             // do anything else you need here, like send an email
  503.             if ($teacher) {
  504.                 return $this->redirectToRoute('app_trainer');
  505.             }
  506.             return $this->redirectToRoute('app_user');
  507.         }
  508.         return $this->render('user/update.html.twig', [
  509.             'setUserForm' => $form->createView(),
  510.             'teacher' => $teacher
  511.         ]);
  512.     }
  514.     #[Route('/user/profileFormateur/{id}', name: 'app_edit_formateur')]
  515.     public function updateFormateurProfile(Request $request, EntityManagerInterface $entityManager, $id): Response
  516.     {
  517.         if($id) {
  518.             $user = $entityManager->getRepository(User::class)->findOneBy(['id' => $id]);
  519.         } else {
  520.             $user = $this->getUser();
  521.         }
  522.         $form = $this->createForm(UpdateUserFormType::class, $user);
  523.         $form->handleRequest($request);
  524.         $teacher = false;
  525.         if (in_array('ROLE_TEACHER', $this->getUser()->getRoles(), true)) {
  526.             $teacher = true;
  527.         }
  528.         if ($form->isSubmitted() && $form->isValid()) {
  529.             $user = $form->getData();
  530.             $entityManager->persist($user);
  531.             $entityManager->flush();
  532.             // do anything else you need here, like send an email
  533.             if ($teacher) {
  534.                 return $this->redirectToRoute('app_trainer');
  535.             }
  536.             return $this->redirectToRoute('app_user');
  537.         }
  538.         return $this->render('user/update.html.twig', [
  539.             'setUserForm' => $form->createView(),
  540.             'teacher' => $teacher
  541.         ]);
  542.     }
  544.     #[Route('/user/loginTeacher/{id}', name: 'app_login_formateur')]
  545.     public function loginTeacher(EntityManagerInterface $entityManager,
  546.                                  UserAuthenticatorInterface $userAuthenticator,
  547.                                  AppAuthenticator $authenticator,
  548.                                  Request $request,
  549.         $id): Response
  550.     {
  551.         if (in_array('ROLE_SUPER_ADMIN', $this->getUser()->getRoles(), true)) {
  552.             $admin =$this->getUser();
  553.             $request->getSession()->set('adminId', $admin->getId());
  554.         }
  556.         // Load the user by ID (assuming Doctrine)
  557.         $user = $entityManager->getRepository(User::class)->findOneBy(['id' => $id]);
  558.         // Authenticate the user
  559.         $userAuthenticator->authenticateUser($user, $authenticator, $request);
  561.         // Redirect to homepage (or another route)
  562.         if (in_array('ROLE_SUPER_ADMIN', $this->getUser()->getRoles(), true)) {
  563.             return $this->redirectToRoute('app_home');
  564.         } else {
  565.             return $this->redirectToRoute('app_home_trainer');
  566.         }
  568.     }
  569. }