src/Controller/Utilisateurs/UtilisateurController.php line 650

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Utilisateurs;
  5. use App\Entity\Bureau;
  6. use App\Entity\Facture;
  7. use App\Entity\FactureFournisseur;
  8. use App\Entity\Notifications;
  9. use App\Entity\PointageUser;
  10. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  11. use Symfony\Component\HttpFoundation\Response;
  12. use Symfony\Component\Routing\Annotation\Route;
  13. use Symfony\Component\HttpFoundation\Request;
  14. use Doctrine\ORM\EntityManagerInterface;
  15. use App\Entity\Utilisateur; 
  16. use App\Entity\Profil; 
  17. use App\Entity\Role; 
  18. use App\Entity\ProfilRole; 
  19. use App\Entity\UtilisateurProfil; 
  20. use App\Entity\TimeWork; 
  21. use App\Service\ValidateService;
  22. use App\Service\BaseService;
  23. use Symfony\Component\HttpFoundation\File\UploadedFile;
  24. use Symfony\Component\HttpFoundation\Session\Session;
  25. use App\Repository\UtilisateurRepository;
  26. use App\Entity\BureauUtilisateur; 
  27. use App\Entity\LogUser; 
  28. use App\Entity\Marche; 
  29. use App\Repository\MarcheRepository;
  30. use App\Repository\PointageUserRepository;
  31. use Symfony\Component\HttpFoundation\JsonResponse;
  33. class UtilisateurController extends AbstractController
  34. {
  35.     public $baseService;
  37.     public function __construct(BaseService $baseService
  38.         )
  39.     {
  40.         $this->baseService = $baseService;
  41.     }
  42.     #[Route('/addUtilisateur', name: 'addUtilisateur')]
  43.     public function addUtilisateur(Request $request, EntityManagerInterface $entityManager,ValidateService $validateService,BaseService $baseService): Response
  44.     {
  45.         $chckAccess = $this->baseService->Role(9);
  46.         if($chckAccess == 0){
  47.             return $this->redirectToRoute('login');
  48.         }else if ($chckAccess == 2){
  49.             return $this->redirectToRoute('infoUtilisateur');
  50.         }
  51.         $session = new Session;
  52.         $user = $session->get('user');
  53.         // $check =  $baseService->checkAcces('AJOUUTIL');
  54.         // if($check == 1)
  55.         // {
  56.         //     $session->remove('user');
  57.         //     $session->set('isConnected',false);
  58.     
  59.         //     return $this->redirectToRoute('login'); // Redirect to 'listBureaux' route
  60.         // }
  61.         // else if ( $check == 2 )
  62.         // {
  63.         //     return $this->redirectToRoute('listBureaux'); // Redirect to 'listBureaux' route
  64.         // }
  65.         
  66.         $bureauSelected = $session->get('bureauSelected');
  68.         $response = ""; 
  69.         $nom = "";
  70.         $prenom = "";
  71.         $tele = "";
  72.         $email = "";
  73.         $dateCrea = new \DateTime();
  74.         $profils = $entityManager->getRepository(Profil::class)->findAll();
  75.         $roles = $entityManager->getRepository(Role::class)->findAll();
  76.         $groupedRoles = [];
  77.         foreach ($roles as $role) {
  78.             $category = $role->getCategorieRole();
  79.             if (!isset($groupedRoles[$category])) {
  80.                 $groupedRoles[$category] = [];
  81.             }
  82.             $groupedRoles[$category][] = $role;
  83.         }
  84.         if($request->getMethod()=='POST')
  85.         {
  87.             $nom=$request->get('nom');
  88.             $prenom=$request->get('prenom');
  89.             $tele=$request->get('tele');
  90.             $email=$request->get('email');
  91.             $type=$request->get('agent');
  92.             $active=$request->get('active');
  93.             $password=$request->get('password');
  94.             $file = $request->files->get('picture');
  95.             $profil=$request->get('profil');
  96.             $rolesChecked=$request->get('roles');
  97.             $ifPerso=$request->get('ifPerso');
  98.             $libelle=$request->get('libelle');
  100.             $utilisateur = $entityManager->getRepository(Utilisateur::class)->findByEmaiUtil($email);
  102.             if($utilisateur)
  103.             {
  104.                 $response = 'L\'email existe déjà, veuillez essayer avec un autre email !';
  106.             }
  107.             else
  108.             {
  110.                 $contraintes = array(
  111.                     "nom" => array("val" => $nom, "length" => 255, "type" => "string", "isBlank" => true),
  112.                     "prenom" => array("val" => $prenom, "length" => 1000, "type" => "string" , "isBlank" => true),
  113.                     "tele" => array("val" => $tele, "length" => 255, "type" => "string" , "isBlank" => true),
  114.                     "email" => array("val" => $email, "length" => 255, "type" => "string" , "isBlank" => true),
  115.                     "password" => array("val" => $password, "length" => 255, "type" => "string" , "isBlank" => true),
  116.                     "file" => array("val" => $file, "type" => "file" , "isBlank" => false),
  117.                 );
  119.                 $valideBureau = $validateService->validateur($contraintes);
  121.                 if($valideBureau === true)
  122.                 {
  124.                     if($ifPerso != 1 && !$profil)
  125.                     {
  126.                         $response = 'Veuillez selectionner au moins un profil !';
  127.                     }
  128.                     else
  129.                     {
  130.                         $utilisateur = new utilisateur();
  131.                         $utilisateur->setNomUtil($nom);
  132.                         $utilisateur->setPrenUtil($prenom);
  133.                         $utilisateur->setEmaiUtil($email);
  134.                         $utilisateur->setTeleUtil($tele);
  135.                         $utilisateur->setPassUtil(sha1($password));
  136.                         if($type === 'on')
  137.                         {
  138.                             $utilisateur->setTypeUtil(2);
  139.                         }
  140.                         else
  141.                         {
  142.                             $utilisateur->setTypeUtil(1);
  143.                         }
  144.                         if($active === 'on'){
  145.                             $utilisateur->setActive(1);
  146.                         }else{
  147.                             $utilisateur->setActive(0);
  148.                         }
  150.                         if ($file instanceof UploadedFile) {
  151.                         
  152.                             $fileName = $baseService->generateUniqueFileName() . '.' . $file->guessExtension();
  153.                             
  154.                             // Move the file to the desired directory
  155.                             $file->move(
  156.                                 $this->getParameter('imagesUserUploadPath'),
  157.                                 $fileName
  158.                             );
  159.             
  160.                             $utilisateur->setLogoUtil($fileName); // Set the file name in the entity
  161.                         }
  162.                         else
  163.                         {
  164.                             $utilisateur->setLogoUtil('user.png');
  165.                         }
  166.             
  167.                         // Persist the Bureau entity and flush it to the database
  168.                         $entityManager->persist($utilisateur);
  169.                         $entityManager->flush();
  171.                         if($ifPerso == 1)
  172.                         {
  173.                             $profil = new Profil();
  174.                             $profil->setLibeProf($libelle);
  175.                             $profil->setDescProf('Profil personalisé');
  176.                             $profil->setDateCrea($dateCrea);
  177.                             if($type === 'on')
  178.                             {
  179.                                 $profil->setTypeProf(2);
  180.                             }
  181.                             else
  182.                             {
  183.                                 $profil->setTypeProf(1);
  184.                             }
  185.                             // Persist the Bureau entity and flush it to the database
  186.                             $entityManager->persist($profil);
  187.                             $entityManager->flush();
  189.                             if($profil)
  190.                             {
  192.                                 foreach ($roles as $role)
  193.                                 {
  194.                                     $profilRole = new ProfilRole();
  195.                                     $profilRole->setLibeProf($libelle);
  196.                                     $profilRole->setidProf($profil->getId());
  197.                                     $profilRole->setidRole($role->getId());
  198.                                     // if (is_array($rolesChecked) && in_array($role->getId(), $rolesChecked))
  199.                                     if(isset($_POST['roles'][$role->getCodeRole()]))
  200.                                     {
  201.                                         $profilRole->setRoleProf(true);
  202.                                     }
  203.                                     else
  204.                                     {
  205.                                         $profilRole->setRoleProf(false);
  206.                                     }
  207.                 
  208.                                     $entityManager->persist($profilRole);
  209.                 
  210.                                 }
  212.                                 $utilisateurRole = new UtilisateurProfil();
  213.                                 $utilisateurRole->setidUtil($utilisateur->getId());
  214.                                 $utilisateurRole->setidProf($profil->getId());
  215.             
  216.                                 $entityManager->persist($utilisateurRole);
  217.                                 $entityManager->flush();
  218.                             
  219.                             }
  220.             
  221.                         }
  222.                         else
  223.                         {
  224.                             foreach ($profil as $p)
  225.                             {
  226.             
  227.                                 $utilisateurRole = new UtilisateurProfil();
  228.                                 $utilisateurRole->setidUtil($utilisateur->getId());
  229.                                 $utilisateurRole->setidProf($p);
  230.             
  231.                                 $entityManager->persist($utilisateurRole);
  232.                                 $entityManager->flush();
  234.                             }
  235.                         }
  237.                         if($bureauSelected != 0)
  238.                         {
  239.                             $bureauUtilisateur = new BureauUtilisateur();
  240.                             $bureauUtilisateur->setidUtil($utilisateur->getId());
  241.                             $bureauUtilisateur->setidBure($bureauSelected);
  242.         
  243.                             $entityManager->persist($bureauUtilisateur);
  244.                             $entityManager->flush();
  245.         
  246.                         }
  247.                         $baseService->addLogAction($user->getId(),'Ajouter un utilisateur',$bureauSelected);
  249.                         $response = 'ok';
  251.                     }
  252.                 }
  253.                 else
  254.                 {
  256.                     $response = 'Veuillez vérifier vos informations, un des champs est vide ou incorrect !';
  257.                     
  258.                 }
  259.             }
  261.         }
  263.         if($response == 'ok')
  264.         {
  265.             return $this->redirectToRoute('listUtilisateurs'); // Redirect to 'listBureaux' route
  267.         }
  268.         
  270.         return $this->render('utilisateur/addUtilisateur.html.twig', [
  271.             'controller_name' => 'UtilisateurController',
  272.             'response' => $response,
  273.             'nom' => $nom,
  274.             'prenom' => $prenom,
  275.             'email' => $email,
  276.             'tele' => $tele,
  277.             'profils' => $profils,
  278.             'roles' => $roles,
  279.             'groupedRoles'=>$groupedRoles
  281.         ]);
  282.     }
  285.     #[Route('/listUtilisateurs', name: 'listUtilisateurs')]
  286.     public function listUtilisateurs(Request $request, EntityManagerInterface $entityManager,BaseService $baseService): Response
  287.     {
  288.         $chckAccess = $this->baseService->Role(8);
  289.         if($chckAccess == 0){
  290.             return $this->redirectToRoute('login');
  291.         }else if ($chckAccess == 2){
  292.             return $this->redirectToRoute('infoUtilisateur');
  293.         }
  294.         $session = new Session;
  295.         $bureauSelected = $session->get('bureauSelected');
  297.         // $check =  $baseService->checkAcces('CONSUTIL');
  298.         // if($check == 1)
  299.         // {
  300.         //     $session->remove('user');
  301.         //     $session->set('isConnected',false);
  302.     
  303.         //     return $this->redirectToRoute('login'); // Redirect to 'listBureaux' route
  304.         // }
  305.         // else if ( $check == 2 )
  306.         // {
  307.         //     return $this->redirectToRoute('listBureaux'); // Redirect to 'listBureaux' route
  308.         // }
  309.         $users = [];
  310.         if($bureauSelected == 0)
  311.         {
  312.             $utilisateurs = $entityManager->getRepository(Utilisateur::class)->findAll();
  313.         }
  314.         else
  315.         {
  316.             $bureauUtilisateurs = $entityManager->getRepository(BureauUtilisateur::class)->findByIdBure($bureauSelected);
  317.         
  318.             // Extract the user IDs from BureauUtilisateur
  319.             $userIds = [];
  320.             foreach ($bureauUtilisateurs as $bureauUtilisateur) {
  321.                 $userIds[] = $bureauUtilisateur->getIdUtil(); // Assuming there's a getUserId method
  322.             }
  323.     
  324.             // Fetch the corresponding Utilisateur data
  325.             $utilisateurs = $entityManager->getRepository(Utilisateur::class)->findBy(['id' => $userIds]);
  327.         }
  328.         foreach($utilisateurs as $a)
  329.         {
  330.             $profils = [];
  331.             $utilisateurProfil = $entityManager->getRepository(UtilisateurProfil::class)->findByIdUtil($a->getId());
  332.             for($i=0;$i<count($utilisateurProfil);$i++)
  333.             {
  334.                 $profil = $entityManager->getRepository(Profil::class)->find($utilisateurProfil[$i]->getIdProf());
  335.                 if($profil)
  336.                 {
  337.                     $profilName = $profil->getLibeProf();
  338.                     $profils[$i] = $profilName;
  339.                 }
  341.             }
  343.             // Créez un tableau associatif contenant toutes les informations de l'utilisateur, y compris les profils
  344.             $user = [
  345.                 'id' => $a->getId(),
  346.                 'nom' => $a->getNomUtil(),
  347.                 'prenom' => $a->getPrenUtil(),
  348.                 'tele' => $a->getTeleUtil(),
  349.                 'email' => $a->getEmaiUtil(),
  350.                 'type' => $a->getTypeUtil(),
  351.                 'profils' => $profils,
  352.             ];
  354.             // Ajoutez l'utilisateur au tableau $users
  355.             $users[] = $user;
  356.         }
  358.         
  359.         
  360.         return $this->render('utilisateur/listUtilisateurs.html.twig', [
  361.             'controller_name' => 'UtilisateurController',
  362.             'utilisateurs' => $users,
  363.         ]);
  364.     }
  367.     #[Route('/updateUtilisateur', name: 'updateUtilisateur')]
  368.     public function updateUtilisateur(Request $request, EntityManagerInterface $entityManager,ValidateService $validateService,BaseService $baseService): Response
  369.     {
  370.         $chckAccess = $this->baseService->Role(10);
  371.         if($chckAccess == 0){
  372.             return $this->redirectToRoute('login');
  373.         }else if ($chckAccess == 2){
  374.             return $this->redirectToRoute('infoUtilisateur');
  375.         }
  376.         $session = new Session;
  377.         $userS = $session->get('user');
  378.         $bureauSelected = $session->get('bureauSelected');
  380.         // $check =  $baseService->checkAcces('MODIUTIL');
  381.         // if($check == 1)
  382.         // {
  383.         //     $session->remove('user');
  384.         //     $session->set('isConnected',false);
  385.     
  386.         //     return $this->redirectToRoute('login'); // Redirect to 'listBureaux' route
  387.         // }
  388.         // else if ( $check == 2 )
  389.         // {
  390.         //     return $this->redirectToRoute('listBureaux'); // Redirect to 'listBureaux' route
  391.         // }
  392.         $response = '';
  393.         $id = $request->get('id');
  394.         $dateCrea = new \DateTime();
  396.         $user = $entityManager->getRepository(Utilisateur::class)->find($id);
  397.         $profils = $entityManager->getRepository(Profil::class)->findAll();
  398.         $roles = $entityManager->getRepository(Role::class)->findAll();
  399.         $utilisateurProfil = $entityManager->getRepository(UtilisateurProfil::class)->findByIdUtil($id);
  401.         if($request->getMethod()=='POST')
  402.         {
  404.             $nom=$request->get('nom');
  405.             $prenom=$request->get('prenom');
  406.             $tele=$request->get('tele');
  407.             $email=$request->get('email');
  408.             $type=$request->get('agent');
  409.             $active=$request->get('active');
  410.             $file = $request->files->get('picture');
  411.             $profil=$request->get('profil');
  412.             $rolesChecked=$request->get('roles');
  413.             $ifPerso=$request->get('ifPerso');
  414.             $libelle=$request->get('libelle');
  417.             $utilisateur = $entityManager->getRepository(Utilisateur::class)->findByEmaiUtil($email);
  419.             if($utilisateur && $user->getEmaiUtil() != $email)
  420.             {
  421.                 $response = 'L\'email existe déjà, veuillez essayer avec un autre email !';
  423.             }
  424.             else
  425.             {
  427.                 $contraintes = array(
  428.                     "nom" => array("val" => $nom, "length" => 255, "type" => "string", "isBlank" => true),
  429.                     "prenom" => array("val" => $prenom, "length" => 1000, "type" => "string" , "isBlank" => true),
  430.                     "tele" => array("val" => $tele, "length" => 255, "type" => "string" , "isBlank" => true),
  431.                     "email" => array("val" => $email, "length" => 255, "type" => "string" , "isBlank" => true),
  432.                     "file" => array("val" => $file, "type" => "file" , "isBlank" => false),
  433.                 );
  434.     
  435.                 $valideBureau = $validateService->validateur($contraintes);
  436.     
  437.                 if($valideBureau === true)
  438.                 {
  441.                     if($ifPerso != 1 && !$profil)
  442.                     {
  443.                         $response = 'Veuillez selectionner au moins un profil !';
  444.                     }
  445.                     else
  446.                     {
  447.                         $user->setNomUtil($nom);
  448.                         $user->setPrenUtil($prenom);
  449.                         $user->setEmaiUtil($email);
  450.                         $user->setTeleUtil($tele);
  451.                         $user->setPassUtil($user->getPassUtil());
  452.                         
  453.                         if($user->getTypeUtil() != 0)
  454.                         {
  455.                             if($type === 'on')
  456.                             {
  457.                                 $user->setTypeUtil(2);
  458.                             }
  459.                             else
  460.                             {
  461.                                 $user->setTypeUtil(1);
  462.                             }
  463.                             
  464.                             if($active === 'on')
  465.                             {
  466.                                 $user->setActive(1);
  467.                             }
  468.                             else
  469.                             {
  470.                                 $user->setActive(0);
  471.                             }
  473.                             
  474.                         }
  475.         
  476.                         if ($file instanceof UploadedFile) {
  477.                         
  478.                             $fileName = $baseService->generateUniqueFileName() . '.' . $file->guessExtension();
  479.                             
  480.                             // Move the file to the desired directory
  481.                             $file->move(
  482.                                 $this->getParameter('imagesUserUploadPath'),
  483.                                 $fileName
  484.                             );
  485.                             
  486.                             $user->setLogoUtil($fileName); // Set the file name in the entity
  487.                         }
  488.                         else
  489.                         {
  490.                             $user->setLogoUtil('user.png');
  491.                         }
  492.             
  493.                         // Persist the Bureau entity and flush it to the database
  494.                         $entityManager->flush();
  495.                         if($userS->getId() == $user->getId())
  496.                         $session->set('user', $user);
  497.     
  498.                         foreach ($utilisateurProfil as $pu)
  499.                         {
  500.                             $entityManager->remove($pu);
  501.     
  502.                         }
  503.     
  504.                         if( $ifPerso == 1)
  505.                         {
  506.                             $profil = new Profil();
  507.                             $profil->setLibeProf($libelle);
  508.                             $profil->setDescProf('Profil personalisé');
  509.                             $profil->setDateCrea($dateCrea);
  510.                             if($type === 'on')
  511.                             {
  512.                                 $profil->setTypeProf(2);
  513.                             }
  514.                             else
  515.                             {
  516.                                 $profil->setTypeProf(1);
  517.                             }
  518.                             // Persist the Bureau entity and flush it to the database
  519.                             $entityManager->persist($profil);
  520.                             $entityManager->flush();
  521.     
  522.                             if($profil)
  523.                             {
  524.     
  525.                                 foreach ($roles as $role)
  526.                                 {
  527.                                     $profilRole = new ProfilRole();
  528.                                     $profilRole->setLibeProf($libelle);
  529.                                     $profilRole->setidProf($profil->getId());
  530.                                     $profilRole->setidRole($role->getId());
  531.                                     if (is_array($rolesChecked) && in_array($role->getId(), $rolesChecked)) 
  532.                                     {
  533.                                         $profilRole->setRoleProf(true);
  534.                                     }
  535.                                     else
  536.                                     {
  537.                                         $profilRole->setRoleProf(false);
  538.                                     }
  539.                 
  540.                                     $entityManager->persist($profilRole);
  541.                 
  542.                                 }
  543.     
  544.                                 $utilisateurRole = new UtilisateurProfil();
  545.                                 $utilisateurRole->setidUtil($user->getId());
  546.                                 $utilisateurRole->setidProf($profil->getId());
  547.             
  548.                                 $entityManager->persist($utilisateurRole);
  549.                                 $entityManager->flush();
  550.                                
  551.                             }
  552.             
  553.                         }
  554.                         else
  555.                         {
  556.                             foreach ($profil as $p)
  557.                             {
  558.             
  559.                                 $utilisateurRole = new UtilisateurProfil();
  560.                                 $utilisateurRole->setidUtil($user->getId());
  561.                                 $utilisateurRole->setidProf($p);
  562.             
  563.                                 $entityManager->persist($utilisateurRole);
  564.                                 $entityManager->flush();
  565.     
  566.                             }
  567.                         }
  568.     
  569.                         $response = 'ok';
  570.                         $baseService->addLogAction($user->getId(),'Modifier un utilisateur',$bureauSelected);
  572.                     }
  573.                     
  574.                 }
  575.                 else
  576.                 {
  577.     
  578.                     $response = 'Veuillez vérifier vos informations, un des champs est vide ou incorrect !';
  579.                 }
  581.             }
  583.         }
  584.         
  585.         if($response == 'ok')
  586.         {
  587.             return $this->redirectToRoute('listUtilisateurs'); // Redirect to 'listBureaux' route
  588.         }
  590.         return $this->render('utilisateur/updateUtilisateur.html.twig', [
  591.             'controller_name' => 'UtilisateurController',
  592.             'utilisateur' => $user,
  593.             'response' => $response,
  594.             'profils' => $profils,
  595.             'utilisateurProfil' => $utilisateurProfil,
  596.             'roles' => $roles
  597.             
  598.         ]);
  599.     }
  601.     #[Route('/deleteUtilisateur/{id}/', name: 'deleteUtilisateur')]
  602.     public function deleteUtilisateur(Request $request, EntityManagerInterface $entityManager,$id,BaseService $baseService): Response
  603.     {
  604.         $chckAccess = $this->baseService->Role(11);
  605.         $response = "";
  606.         if($chckAccess == 0){
  607.             $response = "Vous n'avez pas accès à cette opération";
  608.         }else if ($chckAccess == 2){
  609.             $response = "Vous n'avez pas accès à cette opération";
  610.         }
  611.         if( $response == ""){ 
  612.             $session = new Session;
  613.             $user = $session->get('user');
  614.             $utilisateur = $entityManager->getRepository(Utilisateur::class)->find($id);
  616.             if (!$utilisateur) 
  617.             {
  618.             
  619.                 $response = 'Desolé, ce utilisateur est introuvable !';
  621.             } 
  622.             else 
  623.             {
  624.                 $utilisateurProfils = $entityManager->getRepository(UtilisateurProfil::class)->findByIdUtil($utilisateur->getId());
  625.                 foreach($utilisateurProfils as $up)
  626.                 {
  627.                     $entityManager->remove($up);
  628.                 }
  629.                 // Remove the utilisateur
  630.                 $entityManager->remove($utilisateur);
  631.                 $entityManager->flush();
  632.                 if ($user->getId() == $id )
  633.                 {
  634.                     // Clear the user-related session data
  635.                     $session->remove('user');
  636.                     $session->set('isConnected',false);
  637.             
  638.                 }
  639.                 
  640.                 $response = "ok";
  641.                 
  642.             }
  643.         }
  644.         return new Response($response);
  646.     }
  648.     #[Route('/')]
  649.     #[Route('/login', name: 'login')]
  650.     public function login(Request $request, EntityManagerInterface $entityManager,
  651.     UtilisateurRepository $UtilisateurRepository,BaseService $baseService): Response
  652.     {
  653.         
  654.         $session = new Session;
  655.         // Check if user is connected and exists in the session
  656.         $isConnected = $session->get('isConnected');
  657.         $user = $session->get('user');
  659.         if ($isConnected == true && $user) {
  660.             return $this->redirectToRoute('listBureaux'); // Redirect to 'listBureaux' route
  661.         }
  663.         $response = "";
  664.         $email = "";
  665.         $password = "";
  667.         if($request->getMethod()=='POST')
  668.         {
  670.             $email=$request->get('email');
  671.             $password=$request->get('password');
  673.             if( trim($email) == "" || trim($password) == "" )
  674.             {
  675.                 $response = "L'email ou le mot de passe est vide";
  676.             }
  677.             else
  678.             {
  679.                 $utilisateur = $entityManager->getRepository(Utilisateur::class)->findOneBy(array("emaiUtil" => $email,"passUtil" => sha1($password)));
  680.                 if($utilisateur)
  681.                 {
  682.                     if($utilisateur->getActive() != 1)
  683.                     {
  684.                         $response="Votre compte n'est pas actif !";
  685.                     }else{
  686.                         $findBureau = $entityManager->getRepository(BureauUtilisateur::class)->findBy(['idUtil'=>$utilisateur->getId()]);
  687.                         if($findBureau || $utilisateur->getTypeUtil() == 0){
  688.                             // Store user data in the session
  689.                             $session->set('user', $utilisateur);
  690.                             $session->set('isConnected', true);
  691.         
  692.                             $bureaux = $UtilisateurRepository->getUserBureaux($utilisateur->getId());
  693.                             $allBureaux = $entityManager->getRepository(Bureau::class)->findByEtatBure(1);
  694.                             $session->set('allBureaux', $allBureaux);
  695.         
  696.                             if($bureaux)
  697.                             {
  698.                                 $session->set('bureaux', $bureaux);
  699.                                 $session->set('bureauSelected', $bureaux[0]['id']);    
  700.                             }
  701.                             else
  702.                             {
  703.                                 $session->set('bureauSelected', 0);    
  704.                             }
  705.                             $bureauSelected = $session->get('bureauSelected');
  706.                             $baseService->addLogAction($utilisateur->getId(),'Connexion',$bureauSelected);
  707.                             $utilisateur->setLastConn(new \DateTime());
  708.                             $baseService->verifierNotification();
  709.                             return $this->redirectToRoute('dashboard'); // Replace 'dashboard_route' with your actual route name
  710.                         }else{
  711.                             $response="Votre compte n'est pas accessible pour le travail !";
  712.                         }
  713.                     }
  714.                 }
  715.                 else
  716.                 {
  717.                     $response = "L'email ou le mot de passe est incorrect";
  718.                 }
  719.             }
  720.         }
  721.         
  722.         return $this->render('utilisateur/login.html.twig', [
  723.             'controller_name' => 'UtilisateurController',
  724.             'response' => $response
  725.         ]);
  726.     }
  728.     #[Route('/logout', name: 'logout')]
  729.     public function logout(Request $request, EntityManagerInterface $entityManager,BaseService $baseService): Response
  730.     {
  731.         $session = new Session;
  732.         $bureauSelected = $session->get('bureauSelected');
  733.         $user = $session->get('user');
  735.         $baseService->addLogAction($user->getId(),'Connexion',$bureauSelected);
  737.         // Clear the user-related session data
  738.         $session->remove('user');
  739.         $session->set('isConnected',false);
  742.         // Redirect to the login page
  743.         return $this->redirectToRoute('login'); // Replace 'login' with your actual login route name
  745.     }
  746.     
  747.     #[Route('/chnagerMotDePasse/', name: 'chnagerMotDePasse')]
  748.     public function chnagerMotDePasse(Request $request, EntityManagerInterface $entityManager,BaseService $baseService): Response
  749.     {
  750.         $session = new Session;
  751.         $user = $session->get('user');
  752.         $bureauSelected = $session->get('bureauSelected');
  754.         $response = '';
  755.         $chckAccess = $this->baseService->Role(94);
  756.         if($chckAccess == 0){
  757.             $response = "Vous n'avez pas accès à cette opération";
  758.         }else if ($chckAccess == 2){
  759.             $response = "Vous n'avez pas accès à cette opération";
  760.         }
  761.         if( $response == ""){
  762.             $id = $request->get('id');
  763.             $password = $request->get('password');
  764.             $confirmPassword = $request->get('confirmPassword');
  765.             $utilisateur = $entityManager->getRepository(Utilisateur::class)->find($id);
  766.     
  767.             if (!$utilisateur) 
  768.             {
  769.                 $response = "Désolé, ce utilisateur n'a pas été trouvé !";
  770.             }
  771.             else if($password == "" || $password == null)
  772.             {
  773.                 $response = 'Désolé, le champ du mot de passe est vide. Veuillez le renseigner !';
  774.             }
  775.             else if(strlen($password) < 6)
  776.             {
  777.                 $response = 'Désolé, le mot de passe doit contenir plus de 6 caractères !';
  778.             }
  779.             else if($password != $confirmPassword)
  780.             {
  781.                 $response = 'Désolé, la confirmation du mot de passe ne correspond pas au mot de passe saisi. Veuillez vérifier et réessayer';
  782.             }
  783.             else if($password == $utilisateur->getPassutil())
  784.             {
  785.                 $response = "Désolé, veuillez choisir un nouveau mot de passe différent de l'ancien pour des raisons de sécurité.";
  786.             } 
  787.             else 
  788.             {
  789.     
  790.     
  791.                 // Remove the utilisateur
  792.                 $utilisateur->setPassUtil(sha1($password));
  793.                 $entityManager->flush();
  794.                 $baseService->addLogAction($user->getId(),'Modifier un mot de passe utilisateur',$bureauSelected);
  795.     
  796.                 $response = "ok";
  797.                 
  798.             }
  799.         }
  801.         return new Response($response);
  803.     }
  805.     #[Route('/chnagerBureau/', name: 'chnagerBureau')]
  806.     public function chnagerBureau(Request $request, EntityManagerInterface $entityManager,BaseService $baseService): Response
  807.     {
  808.         $session = new Session;
  809.         // Check if user is connected and exists in the session
  810.         $isConnected = $session->get('isConnected');
  811.         $user = $session->get('user');
  812.         $response = '';
  813.         $id = $request->get('id');
  814.         $session->set('bureauSelected', $id);
  815.         $response = 'ok';
  816.         $baseService->verifierNotification();
  817.         $baseService->addLogAction($user->getId(),'Connexion',$id);
  819.         return new Response($response);
  820.     }
  821.     #[Route('/redirectToNotif/', name: 'redirectToNotif')]
  822.     public function redirectToNotif(Request $request, EntityManagerInterface $entityManager,BaseService $baseService): Response
  823.     {
  824.         $session = new Session;
  825.         // Check if user is connected and exists in the session
  826.         $isConnected = $session->get('isConnected');
  827.         $user = $session->get('user');
  828.         $response = '';
  829.         $id = $request->get('id');
  830.         $notif = $entityManager->getRepository(Notifications::class)->find($id);
  831.         $notif->setEtat(0);
  832.         $entityManager->flush();
  833.         if($notif->getType() == 1){
  834.             $response = '/taches';
  835.         }else if($notif->getType() == 2){
  836.             $response = '/listMissions?tab=1';
  837.         }else if($notif->getType() == 3){
  838.             $fact1 = $entityManager->getRepository(Facture::class)->find($notif->getIdObject());
  839.             
  840.             $response = '/viewFacture?id='.$fact1->getId();
  841.         }else if($notif->getType() == 4){
  842.             $fact = $entityManager->getRepository(FactureFournisseur::class)->find($notif->getIdObject());
  843.             $response = '/assets/images/archive/FactureFournisseur/'.$fact->getImagFacr();
  844.         }
  845.         $baseService->verifierNotification();
  846.         return new Response($response);
  847.     }
  848.     #[Route('/isShowNotif/', name: 'isShowNotif')]
  849.     public function isShowNotif(Request $request, EntityManagerInterface $entityManager,BaseService $baseService): Response
  850.     {
  851.         $session = new Session;
  852.         // Check if user is connected and exists in the session
  853.         $isConnected = $session->get('isConnected');
  854.         $user = $session->get('user');
  855.         $response = '';
  856.         $id = $request->get('id');
  857.         $listeNotif = $session->get('notification');
  858.         for ($i=0; $i < $listeNotif; $i++) { 
  859.             $baseService->updateStatusNotif($listeNotif[$i]['id']);
  860.         }
  861.         $baseService->verifierNotification();
  862.         return new Response($response);
  863.     }
  864.     
  865.     
  866.     #[Route('/logsUtilisateurs')]
  867.     public function logsUtilisateurs(Request $request,UtilisateurRepository $userRepo ,EntityManagerInterface $entityManager,BaseService $baseService,
  868.     MarcheRepository $marcheRepository): Response
  869.     {
  870.         $chckAccess = $this->baseService->Role(7);
  871.         if($chckAccess == 0){
  872.             return $this->redirectToRoute('login');
  873.         }else if ($chckAccess == 2){
  874.             return $this->redirectToRoute('infoUtilisateur');
  875.         }
  877.         $session = new Session;
  878.         $bureauSelected = $session->get('bureauSelected');
  879.         $currentDate = new \DateTime();
  880.         $date_debut = $currentDate->format('Y-m-d');
  881.         $date_fin = $currentDate->format('Y-m-d');
  882.         $marc = 0;
  883.         $user = 0;
  884.         $logs = $userRepo->getLogs($bureauSelected , $date_debut , $date_fin , $marc , $user);
  885.         
  886.         if($bureauSelected == 0){
  887.             $marche = $entityManager->getRepository(Marche::class)->findAll();
  888.             $users = $entityManager->getRepository(Utilisateur::class)->findAll();
  889.         }else{
  890.             //$marche = $entityManager->getRepository(Marche::class)->findBy(['idBure'=>$bureauSelected]);
  891.          
  892.             $marche = $marcheRepository->getMarches($bureauSelected);
  893.             $users = $userRepo->getBureauUsers($bureauSelected);
  895.         }
  896.         if($request->getMethod() == 'POST')
  897.         {
  898.             $date_debut = $request->get('date_debut');
  899.             $date_fin = $request->get('date_fin');
  900.             $marc = $request->get('idMarche');
  901.             $user = $request->get('idUtilisateurs');
  902.             $logs = $userRepo->getLogs($bureauSelected , $date_debut , $date_fin , $marc , $user);
  903.         }
  905.         return $this->render('utilisateur/logs.html.twig', [
  906.             'controller_name' => 'UtilisateurController',
  907.             'logs'=>$logs,
  908.             'marche'=>$marche,
  909.             'users'=>$users,
  910.             'date_debut'=>$date_debut,
  911.             'date_fin'=>$date_fin,
  912.             'user'=>$user,
  913.             'marc'=>$marc,
  914.         ]);
  915.     }
  918.     #[Route('/infoUtilisateur', name: 'infoUtilisateur')]
  919.     public function InfoUtilisateur(Request $request, EntityManagerInterface $entityManager,ValidateService $validateService,BaseService $baseService): Response
  920.     {
  921.         $session = new Session;
  922.         $user = $session->get('user');
  923.         if ($user) {
  924.             $id = $user->getId();
  925.         }
  926.         $response = '';
  927.         // $id = $request->get('id');
  928.         $dateCrea = new \DateTime();
  930.         $user = $entityManager->getRepository(Utilisateur::class)->find($id);
  931.         // var_dump($user);
  932.         $profils = $entityManager->getRepository(Profil::class)->findAll();
  933.         $roles = $entityManager->getRepository(Role::class)->findAll();
  934.         $utilisateurProfil = $entityManager->getRepository(UtilisateurProfil::class)->findByIdUtil($id);
  936.         return $this->render('utilisateur/infoUtilisateur.html.twig', [
  937.             'controller_name' => 'UtilisateurController',
  938.             'utilisateur' => $user,
  939.             'response' => $response,
  940.             'profils' => $profils,
  941.             'utilisateurProfil' => $utilisateurProfil,
  942.             'roles' => $roles
  943.             
  944.         ]);
  945.     }
  946.     #[Route('/pointage', name: 'pointage')]
  947.     public function pointage(Request $request , BaseService $baseService , PointageUserRepository $PointageUserRepository): Response
  948.     {
  949.         $chckAccess = $this->baseService->Role(128);
  950.         if($chckAccess == 0){
  951.             return $this->redirectToRoute('login');
  952.         }else if ($chckAccess == 2){
  953.             return $this->redirectToRoute('infoUtilisateur');
  954.         }
  955.         $response = "";
  956.         $currentDate = new \DateTime();
  957.         $session = new Session;
  958.         $bureauSelected = $session->get('bureauSelected');
  959.         $currentDate->modify('first day of this month');
  960.         $date_debut = $currentDate->format('Y-m-d');
  961.         $currentDate->modify('last day of this month');
  962.         $date_fin = $currentDate->format('Y-m-d');
  964.         $year = date('Y');
  965.         $month = date('m');
  967.         // Create a DateTime object for the first day of the specified month and year
  968.         $firstDay = new \DateTime("$year-$month-01");
  970.         // Get the last day of the month by modifying the first day
  971.         $lastDay = clone $firstDay;
  972.         $lastDay->modify('last day of this month');
  974.         // Format the dates as strings in 'Y-m-d' format
  975.         $dateDay = date('Y-m-d');
  976.         $date_debut = $dateDay ;
  977.         $date_fin = $dateDay;
  978.         $listPointage = $PointageUserRepository->workTimeListeByDate($date_debut , $date_fin);
  979.         if($request->getMethod() == 'POST'){
  980.             $date_debut = $request->get("date_debut");
  981.             $date_fin = $request->get("date_fin");
  982.             if($date_fin < $date_debut){
  983.                 $response="Veuillez vérifier date saisie !!";
  984.                 $currentDate->modify('first day of this month');
  985.                 $date_debut = $currentDate->format('Y-m-d');
  986.                 $currentDate->modify('last day of this month');
  987.                 $date_fin = $currentDate->format('Y-m-d');
  988.             }else{
  989.                 $listPointage = $PointageUserRepository->workTimeListeByDate($date_debut , $date_fin);
  990.             }
  991.         }
  992.         return $this->render('utilisateur/pointage.html.twig', [
  993.             'controller_name' => 'UtilisateurController',
  994.             'date_debut' => $date_debut,
  995.             'date_fin' => $date_fin,
  996.             'response'=>$response,
  997.             'pointage'=>$listPointage,
  998.             'dateDay'=>$dateDay
  999.         ]);
  1000.     }
  1002.     #[Route('/workPointageBackOffice', name: 'workPointageBackOffice')]
  1003.     public function workPointageBackOffice(Request $request, EntityManagerInterface $entityManager,PointageUserRepository $PointageUserRepository): Response
  1004.     {
  1005.         $session = new Session;
  1006.         // Check if user is connected and exists in the session
  1007.         $isConnected = $session->get('isConnected');
  1008.         $user = $session->get('user');
  1009.         $response = '';
  1010.         $dateDay = date('Y-m-d');
  1011.         $idUser = $request->get('idUser');
  1013.         $data = $PointageUserRepository->workTimeListeByUser($dateDay , $idUser);
  1015.         return new JsonResponse(['data' => $data]);
  1016.     }
  1017.     #[Route('/deletePointage/{id}', name: 'deletePointage')]
  1018.     public function deletePointage(Request $request, $id , EntityManagerInterface $entityManager,PointageUserRepository $PointageUserRepository): Response
  1019.     {
  1020.         $session = new Session;
  1021.         // Check if user is connected and exists in the session
  1022.         $isConnected = $session->get('isConnected');
  1023.         $user = $session->get('user');
  1024.         $response = '';
  1025.         $dateDay = date('Y-m-d');
  1026.         $pointageUser = $entityManager->getRepository(PointageUser::class)->find($id);
  1027.         if($pointageUser->getIdUser() == $user->getId() || $user->getTypeUtil() == 0 ){
  1028.             if($pointageUser){
  1029.                 $result = $PointageUserRepository->checkForDeletePointage($pointageUser->getIdUser() , $pointageUser->getTypePointage());
  1030.                 if($result == "OK"){
  1032.                     $entityManager->remove($pointageUser);
  1033.                     $date = \DateTime::createFromFormat('Y-m-d H:i:s', $dateDay. '00:00:00');
  1034.                     $time_work = $entityManager->getRepository(TimeWork::class)->findOneBy(['date'=>$date, 'id_user'=>$pointageUser->getIdUser()]);
  1036.                     if($pointageUser->getTypePointage() == 4){
  1037.                         $time_work->setTime(00);
  1038.                     }else if ($pointageUser->getTypePointage() == 1){
  1039.                         $entityManager->remove($time_work);
  1040.                     }
  1042.                     $entityManager->flush();
  1043.                     $response = "OK"; 
  1044.                 }else{
  1045.                     $response = $result;
  1046.                 }
  1047.             }
  1048.         }else{
  1049.             $response = 'Vous n\'êtes pas le pointeur !';
  1050.         }
  1051.         return new JsonResponse(['response' => $response]);
  1052.     }
  1053.     
  1054. }