src/Controller/Utilisateurs/UtilisateurController.php line 379

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