src/Controller/UserController.php line 220

  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\Request;
  18. use Symfony\Component\HttpFoundation\Response;
  19. use Symfony\Component\HttpFoundation\StreamedResponse;
  20. use Symfony\Component\Mailer\MailerInterface;
  21. use Symfony\Component\Mime\Email;
  22. use Symfony\Component\Routing\Annotation\Route;
  23. use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
  24. use Symfony\Component\Security\Core\Security;
  25. use Symfony\Component\Security\Http\Authentication\UserAuthenticatorInterface;
  26. use App\Security\AppAuthenticator;
  27. use Doctrine\ORM\EntityManagerInterface;
  29. class UserController extends AbstractController
  30. {
  31.     /** User CRUD */
  32.     #[Route('/user', name: 'app_user')]
  33.     public function index(EntityManagerInterface $entityManager): Response
  34.     {
  35.         $users = $entityManager->getRepository(User::class)->findUsers("ROLE_SUPER_ADMIN");
  36.         return $this->render('user/index.html.twig', [
  37.             'users' => $users,
  38.         ]);
  39.     }
  41.     #[Route('/user/add', name: 'app_add_user')]
  42.     public function addUser(Request $request, UserPasswordHasherInterface $userPasswordHasher, UserAuthenticatorInterface $userAuthenticator, EntityManagerInterface $entityManager): Response
  43.     {
  44.         $user = new User();
  45.         $form = $this->createForm(RegistrationFormType::class, $user);
  46.         $form->handleRequest($request);
  47.         if ($form->isSubmitted() && $form->isValid()) {
  48.              // Créer une instance de l'entité User avec les données du formulaire
  49.             $user = $form->getData();
  51.             // Définir le rôle de l'utilisateur en tant qu'utilisateur
  52.             $user->setRoles(['ROLE_SUPER_ADMIN']);
  53.             // encode the plain password
  54.             $user->setPassword(
  55.                 $userPasswordHasher->hashPassword(
  56.                     $user,
  57.                     $form->get('password')->getData()
  58.                 )
  59.             );
  60.             $entityManager->persist($user);
  61.             $entityManager->flush();
  62.             // do anything else you need here, like send an email
  63.             return $this->redirectToRoute('app_user');
  64.         }
  65.         return $this->render('user/new.html.twig', [
  66.             'registrationForm' => $form->createView(),
  67.         ]);
  68.     }
  70.     #[Route('/user/profile/{id}', name: 'app_edit_user')]
  71.     public function updateUserProfile(Request $request, EntityManagerInterface $entityManager, $id): Response
  72.     {
  73.         if($id) {
  74.             $user = $entityManager->getRepository(User::class)->findOneBy(['id' => $id]);
  75.         } else {
  76.             $user = $this->getUser();
  77.         }
  78.         $form = $this->createForm(UpdateUserFormType::class, $user);
  79.         $form->handleRequest($request);
  80.         $teacher = false;
  81.         if (in_array('ROLE_TEACHER', $this->getUser()->getRoles(), true)) {
  82.             $teacher = true;
  83.         }
  84.         if ($form->isSubmitted() && $form->isValid()) {
  85.             $user = $form->getData();
  86.             $entityManager->persist($user);
  87.             $entityManager->flush();
  88.             // do anything else you need here, like send an email
  89.             if ($teacher) {
  90.                 return $this->redirectToRoute('app_trainer');
  91.             }
  92.             return $this->redirectToRoute('app_user');
  93.         }
  94.         return $this->render('user/update.html.twig', [
  95.             'setUserForm' => $form->createView(),
  96.             'teacher' => $teacher
  97.         ]);
  98.     }
  99.     /** Trainees CRUD */
  100.     #[Route('/user/trainees', name: 'app_trainees')]
  101.     public function listOfTrainees(EntityManagerInterface $entityManager): Response
  102.     {
  103.         $users = $entityManager->getRepository(Trainee::class)->findBy([],['id' => 'DESC']);
  104.         $isTeacher = false;
  105.         if (in_array('ROLE_TEACHER', $this->getUser()->getRoles(), true)) {
  106.             $isTeacher = true;
  107.         }
  108.         return $this->render('trainees/trainees.html.twig', [
  109.             'users' => $users,
  110.             'base_template' => $isTeacher ? 'baseTeacher.html.twig' : 'baseAdmin.html.twig'
  111.         ]);
  112.     }
  114.     #[Route('/user/addTrainee/{formationId}', name: 'app_add_trainee')]
  115.     public function addTrainees(Request $request, EntityManagerInterface $entityManager, $formationId = null): Response
  116.     {
  117.         $user = new Trainee();
  118.         $form = $this->createForm(TraineeFormType::class, $user);
  119.         $form->handleRequest($request);
  120.         $type = "";
  121.         if($formationId) {
  122.             $formation = $entityManager->getRepository(Formation::class)->findOneBy(['id' => $formationId]);
  123.             $type = $formation->getType();
  124.         }
  125.         if ($form->isSubmitted() && $form->isValid()) {
  126.             $user = $form->getData();
  127.             $entityManager->persist($user);
  128.             $entityManager->flush();
  129.             if($formationId) {
  130.                 $formation  = $entityManager->getRepository(Formation::class)->findOneBy(['id'=> $formationId]);
  131.                 $TraineeFormation = new TraineeFormation();
  132.                 $TraineeFormation->setTrainee($user);
  133.                 $TraineeFormation->setFormation($formation);
  134.                 $entityManager->persist($TraineeFormation);
  135.                 $entityManager->flush();
  136.                 return $this->redirectToRoute('app_courses_manage', ['idFormation' => $formationId, 'type' => $formation->getType()]);
  137.             } else {
  138.                 return $this->redirectToRoute('app_trainees');
  139.             }
  140.         }
  141.         $isTeacher = false;
  142.         if (in_array('ROLE_TEACHER', $this->getUser()->getRoles(), true)) {
  143.             $isTeacher = true;
  144.         }
  145.         return $this->render('trainees/new_trainee.html.twig', [
  146.             'registrationForm' => $form->createView(),
  147.             'formationId' => $formationId,
  148.             'typeFormation' => $type,
  149.             'base_template' => $isTeacher ? 'baseTeacher.html.twig' : 'baseAdmin.html.twig'
  150.         ]);
  151.     }
  152.     /** Teacher CRUD */
  153.     #[Route('/user/teachers', name: 'app_teachers')]
  154.     public function listOfTeacher(EntityManagerInterface $entityManager): Response
  155.     {
  156.         $users = $entityManager->getRepository(User::class)->findUsers('ROLE_TEACHER');
  157.         return $this->render('user/teachers.html.twig', [
  158.             'users' => $users,
  159.         ]);
  160.     }
  162.     #[Route('/user/addTeacher', name: 'app_add_teacher')]
  163.     public function addTeacher(Request $request, EntityManagerInterface $entityManager, UserPasswordHasherInterface $userPasswordHasher): Response
  164.     {
  165.         $user = new User();
  166.         $form = $this->createForm(UpdateUserFormType::class, $user);
  167.         $form->handleRequest($request);
  168.         if ($form->isSubmitted() && $form->isValid()) {
  169.             $user = $form->getData();
  170.             //set default password for Trainees 00000000
  171.             $user->setPassword(
  172.                 $userPasswordHasher->hashPassword(
  173.                     $user,
  174.                     '00000000'
  175.                 )
  176.             );
  178.             $user->setRoles(['ROLE_TEACHER']);
  179.             $entityManager->persist($user);
  180.             $entityManager->flush();
  181.             return $this->redirectToRoute('app_teachers');
  182.         }
  183.         return $this->render('user/new_teacher.html.twig', [
  184.             'registrationForm' => $form->createView(),
  185.         ]);
  186.     }
  188.     #[Route('/trainee/edit/{id}/{idFormation}', name: 'app_edit_trainee')]
  189.     public function updateTrainee(Request $request, EntityManagerInterface $entityManager, $id, $idFormation = null): Response
  190.     {
  191.         $user = $entityManager->getRepository(Trainee::class)->findOneBy(['id' => $id]);
  192.         $form = $this->createForm(TraineeFormType::class, $user);
  193.         $type = "";
  194.         if($idFormation) {
  195.             $formation = $entityManager->getRepository(Formation::class)->findOneBy(['id' => $idFormation]);
  196.             $type = $formation->getType();
  197.         }
  198.         $form->handleRequest($request);
  199.         if ($form->isSubmitted() && $form->isValid()) {
  200.             $user = $form->getData();
  201.             $entityManager->persist($user);
  202.             $entityManager->flush();
  203.             if ($idFormation !== null) {
  204.                 return $this->redirectToRoute('app_courses_manage', ['type' => $type, 'idFormation' => $idFormation]);
  205.             }
  206.             return $this->redirectToRoute('app_trainees');
  207.         }
  208.         $isTeacher = false;
  209.         if (in_array('ROLE_TEACHER', $this->getUser()->getRoles(), true)) {
  210.             $isTeacher = true;
  211.         }
  212.         return $this->render('trainees/update_trainee.html.twig', [
  213.             'setTraineeForm' => $form->createView(),
  214.             'typeFormation' => $type,
  215.             'base_template' => $isTeacher ? 'baseTeacher.html.twig' : 'baseAdmin.html.twig'
  216.         ]);
  217.     }
  219.     #[Route('/update-password', name: 'app_update_password')]
  220.     public function updatePassword(Request $request, EntityManagerInterface $entityManager, MailerInterface $mailer): Response
  221.     {
  222.         if ($request->isMethod('POST')) {
  223.             $email = $request->request->get('email');
  224.             if($email != "") {
  225.                 $user = $entityManager->getRepository(User::class)->findOneBy(['email' => $email]);
  226.                 if ($user) {
  227.                     //send mail to user with token
  228.                     $link = 'https://adformation.online'.$this->generateUrl('app_update_user_password',['email'=>$email]);
  229.                     $emailToSend = (new Email())
  230.                         ->from('noreply-formation@adconseil.eu')
  231.                         ->subject('Modification de mot de passe')
  232.                         ->html('<p>Bonjour, cliquer sur le lien pour modifier votre mot de passe:<br><a href="'.$link.'">'.$link.'</a></p>')
  233.                         ->to($user->getEmail());
  234.                     $mailer->send($emailToSend);
  235.                     $this->addFlash('success', "Un email est envoyé à votre compte.");
  236.                     return $this->redirectToRoute('app_update_password');
  237.                 } else {
  238.                     // show error message
  239.                     $this->addFlash('warning', "Cet email n'existe pas!");
  240.                     return $this->redirectToRoute('app_update_password');
  241.                 }
  242.             }
  243.             return $this->redirectToRoute('app_update_password');
  244.         }
  245.         return $this->render('security/resetPassword.html.twig', [
  246.         ]);
  247.     }
  249.     #[Route('/update-user-password/{email}', name: 'app_update_user_password')]
  250.     public function updateUserPassword(Request $request, EntityManagerInterface $entityManager,UserPasswordHasherInterface $userPasswordHasher, $email): Response
  251.     {
  252.         if ($request->isMethod('POST')) {
  253.             $password= $request->request->get('password');
  254.             if($email != "" && $password != "") {
  255.                 $user = $entityManager->getRepository(User::class)->findOneBy(['email' => $email]);
  256.                 if ($user) {
  257.                     //update password
  258.                     $user->setPassword(
  259.                         $userPasswordHasher->hashPassword(
  260.                             $user,
  261.                             $password
  262.                         )
  263.                     );
  264.                     $entityManager->persist($user);
  265.                     $entityManager->flush();
  266.                     $this->addFlash('success', "Votre mot de passe aura été changé avec succès");
  267.                     return $this->redirectToRoute('app_login');
  268.                 } else {
  269.                     // show error message
  270.                     $this->addFlash('warning', "Le lien est incorrect");
  271.                     return $this->redirectToRoute('app_update_user_password');
  272.                 }
  273.             }
  274.             return $this->redirectToRoute('app_login');
  275.         }
  276.         return $this->render('security/newPassword.html.twig', [
  277.         ]);
  278.     }
  279.     #[Route('/trainee/delete/{id}', name: 'app_delete_trainee')]
  280.     public function deleteTrainee(EntityManagerInterface $entityManager, $id): Response
  281.     {
  282.         $trainee = $entityManager->getRepository(Trainee::class)->findOneBy(['id' => $id]);
  283.         $traineeFormation = $entityManager->getRepository(TraineeFormation::class)->findBy(['trainee' => $trainee]);
  284.         //find if trainee is affected to formation
  285.         $object = new \stdClass();
  286.         if($traineeFormation) {
  287.             foreach ($traineeFormation as $trfor) {
  288.                  $entityManager->remove($trfor);
  289.             }
  290.             $entityManager->flush();
  291.         }
  293.         $entityManager->remove($trainee);
  294.         $entityManager->flush();
  295.         $object->status = true;
  296.         $object->message = "Le stagiaire est supprimé avec succès";
  297.         return new Response(json_encode($object));
  298.     }
  299.     #[Route('/teacher/delete/{id}', name: 'app_delete_teacher')]
  300.     public function deleteTeacher(EntityManagerInterface $entityManager, $id): Response
  301.     {
  302.         $teacher = $entityManager->getRepository(User::class)->findOneBy(['id' => $id]);
  303.         //find if trainee is affected to formation
  304.         $teacherFormation = $entityManager->getRepository(Formation::class)->findOneBy(['formateur' => $teacher]);
  305.         $object = new \stdClass();
  306.         if ($teacherFormation) {
  307.             $object->status = false;
  308.             $object->message = "Ce formateur est enregistré dans une formation et il est impossible de le supprimer.";
  309.         } else {
  310.             $entityManager->remove($teacher);
  311.             $entityManager->flush();
  312.             $object->status = true;
  313.             $object->message = "Le formateur est supprimé avec succès";
  314.         }
  315.         return new Response(json_encode($object));
  316.     }
  318.     #[Route('/user/delete/{id}', name: 'app_delete_user')]
  319.     public function deleteUser(EntityManagerInterface $entityManager, $id): Response
  320.     {
  321.         $user = $entityManager->getRepository(User::class)->findOneBy(['id' => $id]);
  322.         $object = new \stdClass();
  323.         $entityManager->remove($user);
  324.         $entityManager->flush();
  325.         $object->status = true;
  326.         $object->message = "L'utilisateur est supprimé avec succès";
  327.         return new Response(json_encode($object));
  328.     }
  330.     #[Route('/downloadTrainee', name: 'app_download_trainee')]
  331.     public function downloadTrainee(EntityManagerInterface $entityManager): Response
  332.     {
  333.         $users = $entityManager->getRepository(Trainee::class)->findBy([],['id' => 'DESC']);
  334.         $spreadsheet = new Spreadsheet();
  335.         $sheet = $spreadsheet->getActiveSheet();
  336.         $sheet->setCellValue('A1', 'Nom');
  337.         $sheet->setCellValue('B1', 'Prénom');
  338.         $sheet->setCellValue('C1', 'Fonction');
  339.         $sheet->setCellValue('D1', 'Email');
  340.         $counter = 2;
  341.         foreach ($users as $user) {
  342.             $sheet->setCellValue('A' . $counter, $user->getFirstName());
  343.             $sheet->setCellValue('B' . $counter, $user->getLastName());
  344.             $sheet->setCellValue('C' . $counter, $user->getPosition());
  345.             $sheet->setCellValue('D' . $counter, $user->getEmail());
  346.             $counter++;
  347.         }
  348.         $writer = new Xls($spreadsheet);
  349.         $response =  new StreamedResponse(
  350.             function () use ($writer) {
  351.                 $writer->save('php://output');
  352.             }
  353.         );
  354.         $fileName = "ExportEmails_".date('m-d-Y_hia').".xls";
  355.         $response->headers->set('Content-Type', 'application/vnd.ms-excel');
  356.         $response->headers->set('Content-Disposition', 'attachment; filename=' . '"' . $fileName . '"');
  357.         $response->headers->set('Cache-Control','max-age=0');
  358.         return $response;
  359.         //$this->addFlash('success', "Les stagiaires sont télechargées avec succès.");
  360.        // return $this->redirectToRoute('app_trainees');
  361.     }
  363.     #[Route('/downloadTraineeByFormation/{idFormation}', name: 'app_download_trainee_by_formation')]
  364.     public function downloadTraineeByFormation(EntityManagerInterface $entityManager, $idFormation = null): Response
  365.     {
  366.         $course =  $entityManager->getRepository(Formation::class)->find($idFormation);
  367.         $formationUser = $entityManager->getRepository(TraineeFormation::class)->findBy(['formation' => $course]);
  368.         $spreadsheet = new Spreadsheet();
  369.         $sheet = $spreadsheet->getActiveSheet();
  370.         $sheet->setCellValue('A1', 'Nom');
  371.         $sheet->setCellValue('B1', 'Prénom');
  372.         $sheet->setCellValue('C1', 'Fonction');
  373.         $sheet->setCellValue('D1', 'Email');
  374.         $counter = 2;
  375.         foreach ($formationUser as $item) {
  376.             $sheet->setCellValue('A' . $counter, $item->getTrainee()->getFirstName());
  377.             $sheet->setCellValue('B' . $counter, $item->getTrainee()->getLastName());
  378.             $sheet->setCellValue('C' . $counter, $item->getTrainee()->getPosition());
  379.             $sheet->setCellValue('D' . $counter, $item->getTrainee()->getEmail());
  380.             $counter++;
  381.         }
  382.         $writer = new Xls($spreadsheet);
  383.         $response =  new StreamedResponse(
  384.             function () use ($writer) {
  385.                 $writer->save('php://output');
  386.             }
  387.         );
  388.         $fileName = "ExportEmails_".str_replace(' ','',$course->getNomFormation())."_".date('m-d-Y_hia').".xls";
  389.         $response->headers->set('Content-Type', 'application/vnd.ms-excel');
  390.         $response->headers->set('Content-Disposition', 'attachment; filename=' . '"' . $fileName . '"');
  391.         $response->headers->set('Cache-Control','max-age=0');
  392.         return $response;
  393.         //$this->addFlash('success', "Les stagiaires sont télechargées avec succès.");
  394.         // return $this->redirectToRoute('app_trainees');
  395.     }
  397.     #[Route('/user/profileAdmin/{id}', name: 'app_edit_admin')]
  398.     public function updateAdminProfile(Request $request, EntityManagerInterface $entityManager, $id): Response
  399.     {
  400.         if($id) {
  401.             $user = $entityManager->getRepository(User::class)->findOneBy(['id' => $id]);
  402.         } else {
  403.             $user = $this->getUser();
  404.         }
  405.         $form = $this->createForm(UpdateUserFormType::class, $user);
  406.         $form->handleRequest($request);
  407.         $teacher = false;
  408.         if (in_array('ROLE_TEACHER', $this->getUser()->getRoles(), true)) {
  409.             $teacher = true;
  410.         }
  411.         if ($form->isSubmitted() && $form->isValid()) {
  412.             $user = $form->getData();
  413.             $entityManager->persist($user);
  414.             $entityManager->flush();
  415.             // do anything else you need here, like send an email
  416.             if ($teacher) {
  417.                 return $this->redirectToRoute('app_trainer');
  418.             }
  419.             return $this->redirectToRoute('app_user');
  420.         }
  421.         return $this->render('user/update.html.twig', [
  422.             'setUserForm' => $form->createView(),
  423.             'teacher' => $teacher
  424.         ]);
  425.     }
  427.     #[Route('/user/profileFormateur/{id}', name: 'app_edit_formateur')]
  428.     public function updateFormateurProfile(Request $request, EntityManagerInterface $entityManager, $id): Response
  429.     {
  430.         if($id) {
  431.             $user = $entityManager->getRepository(User::class)->findOneBy(['id' => $id]);
  432.         } else {
  433.             $user = $this->getUser();
  434.         }
  435.         $form = $this->createForm(UpdateUserFormType::class, $user);
  436.         $form->handleRequest($request);
  437.         $teacher = false;
  438.         if (in_array('ROLE_TEACHER', $this->getUser()->getRoles(), true)) {
  439.             $teacher = true;
  440.         }
  441.         if ($form->isSubmitted() && $form->isValid()) {
  442.             $user = $form->getData();
  443.             $entityManager->persist($user);
  444.             $entityManager->flush();
  445.             // do anything else you need here, like send an email
  446.             if ($teacher) {
  447.                 return $this->redirectToRoute('app_trainer');
  448.             }
  449.             return $this->redirectToRoute('app_user');
  450.         }
  451.         return $this->render('user/update.html.twig', [
  452.             'setUserForm' => $form->createView(),
  453.             'teacher' => $teacher
  454.         ]);
  455.     }
  457.     #[Route('/user/loginTeacher/{id}', name: 'app_login_formateur')]
  458.     public function loginTeacher(EntityManagerInterface $entityManager,
  459.                                  UserAuthenticatorInterface $userAuthenticator,
  460.                                  AppAuthenticator $authenticator,
  461.                                  Request $request,
  462.         $id): Response
  463.     {
  464.         if (in_array('ROLE_SUPER_ADMIN', $this->getUser()->getRoles(), true)) {
  465.             $admin =$this->getUser();
  466.             $request->getSession()->set('adminId', $admin->getId());
  467.         }
  469.         // Load the user by ID (assuming Doctrine)
  470.         $user = $entityManager->getRepository(User::class)->findOneBy(['id' => $id]);
  471.         // Authenticate the user
  472.         $userAuthenticator->authenticateUser($user, $authenticator, $request);
  474.         // Redirect to homepage (or another route)
  475.         if (in_array('ROLE_SUPER_ADMIN', $this->getUser()->getRoles(), true)) {
  476.             return $this->redirectToRoute('app_home');
  477.         } else {
  478.             return $this->redirectToRoute('app_home_trainer');
  479.         }
  481.     }
  482. }