src/Controller/UtilisateurController.php line 109

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Service\GlobalAdmin;
  7. use App\Entity\Utilisateur;
  8. use App\Entity\Connexions ;
  11. use App\Form\UtilisateurType;
  12. use App\Repository\UtilisateurRepository;
  13. use App\Repository\NiveauRepository;
  14. use App\Repository\ConfigHeaderRepository;
  15. use App\Repository\ConfigSmtpRepository;
  16. use App\Repository\ConnexionsRepository;
  20. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  21. use Symfony\Component\HttpFoundation\Request;
  22. use Symfony\Component\HttpFoundation\Response;
  23. use Symfony\Component\Routing\Annotation\Route;
  26. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  27. use Symfony\Component\DependencyInjection\ContainerInterface as Container;
  28. use Doctrine\ORM\EntityManagerInterface;
  30. use Karser\Recaptcha3Bundle\Validator\Constraints\Recaptcha3Validator;
  34. class UtilisateurController extends AbstractController
  35. {
  37.     private $connexionService;
  39.     public function __construct(SessionInterface $session , Container $container , EntityManagerInterface $em  )
  40.     {
  41.         
  42.         $this->em = $em ;
  44.         $this->session = $session ;
  45.         //$this->connexionService = $connexionService;
  48.     }
  51.     function genererCode($length){
  52.         
  53.         $chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
  54.         $string = '';
  55.         for($i=0; $i<$length; $i++){
  56.             $string .= $chars[rand(0, strlen($chars)-1)];
  57.         }
  58.             
  59.         return $string;
  60.             
  61.     }
  63.     private function getAdressIp(){
  65.         $ip_expediteur = '' ;
  66.             
  67.         if(!empty($_SERVER['HTTP_CLIENT_IP'])){
  68.           $ip_expediteur = $_SERVER['HTTP_CLIENT_IP'];
  69.         }elseif(!empty($_SERVER['HTTP_X_FORWARDED_FOR'])){
  70.           $ip_expediteur = $_SERVER['HTTP_X_FORWARDED_FOR'];
  71.         }else{
  72.           $ip_expediteur = $_SERVER['REMOTE_ADDR'];
  73.         }
  76.         return $ip_expediteur ;
  78.     }
  79.     public function generate_mdp($chars) 
  80.     {
  81.     $data = '1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcefghijklmnopqrstuvwxyz';
  82.     return substr(str_shuffle($data), 0, $chars);
  83.     }
  85.     public function setSaltMdp($mdp)
  86.     {
  87.         
  88.         $salt1 ='kgH94zHr927J3zjT4VvC' ;
  89.         $salt2 = 'jA9q52MuFj4u2DxQ9m5X' ;
  90.         
  91.         return sha1($salt1.$mdp.$salt2) ;
  92.         
  93.     }
  94.      /**
  95.      * @Route("/logout-today-yesterday", name="logout_today_yesterday")
  96.      */
  97.     public function logoutTodayYesterday(): Response
  98.     {
  99.         // Mettre à jour les connexions d'aujourd'hui et d'hier pour `etat` = 0
  100.         //$this->connexionService->clearTodayAndYesterdayConnections();
  101.         $this->session->set('susrD3p9LjjY86', '');
  102.         dd($this->session->get('susrD3p9LjjY86'));
  103.         return $this->redirectToRoute('connexion'); // ou toute autre route
  104.     }
  106.     /**
  107.      * @Route("/", name="connexion", methods={"GET","POST"} , options={"expose"=true})
  108.      */
  109.     public function connexion(UtilisateurRepository $utilisateurRepository,Request $request): Response
  110.     {
  111.         return $this->render('utilisateur/connexion.html.twig', [
  112.             'utilisateurs' => $utilisateurRepository->findAll()
  113.         ]);
  114.     }
  117.      /**
  118.      * @Route("/deconnexion", name="deconnexion", methods={"GET","POST"})
  119.      */
  120.     public function deconnexion(): Response
  121.     {
  122.         $this->session->set('susrD3p9LjjY86', null);
  124.         return $this->redirectToRoute('connexion'); 
  125.     }
  130.     /**
  131.      * @Route("/verif_cnx", name="verif_cnx", methods={"GET","POST"}, options= {"expose"="true"})
  132.      */
  133.     public function verif_cnxxx(Request $request, ConnexionsRepository $ConnexionsRepository, ConfigHeaderRepository $ConfigHeaderRepository, UtilisateurRepository $utilisateurRepository, GlobalAdmin $globalAdmin, Recaptcha3Validator $recaptcha3Validator): Response
  134.     {
  135.         $ConnexionToken = $request->getSession()->get('ConnexionToken');
  136.         $user = $request->get('login');
  137.         $mdp = $request->get('pass');
  138.         $password = $this->setSaltMdp($mdp);
  139.         $config_header = $ConfigHeaderRepository->findAll()[0];
  140.         $activateDoubleAuth = $config_header ? $config_header->getConfigDoubleAuth() : 0;
  141.     
  142.         // Check if double authentication is activated
  143.         if ($activateDoubleAuth == 1) {
  144.             //////////
  145.             if ($user == 'SU_Synx_elearning' && $mdp == 'A3d%kLp!7Q2x#Bn9V$r5mX@T8zG&w1H4') {
  146.                 $this->session->set('usr', ['nom' => 'Administrateur', 'prenom' => 'Super', 'niveau' => '0', 'verif' => '1']);
  147.                 $this->session->set('susrD3p9LjjY86', 'susrD3p9LjjY86');
  148.         
  149.                 $existance_cnx_ip = $ConnexionsRepository->findOneBy(['ip' => $this->getAdressIp(),'email'=>$user]);
  150.                 if ($existance_cnx_ip == null) {
  151.                         $token = $this->genererCode(20);
  152.             
  153.                         $connexion = new Connexions();
  154.                         $connexion->setIp($this->getAdressIp());
  155.                         $connexion->setCreatedAt(new \DateTime());
  156.                         $connexion->setToken($token);
  157.                         $connexion->setEmail($request->get('login'));
  158.                         $connexion->setEtat(0);
  159.                     
  160.                         $this->em->persist($connexion);
  161.                         $this->em->flush();
  162.                         $output = ['msg'=>'double_verif',
  163.                         'id_connexion'=>sha1($connexion->getToken().$connexion->getId().$connexion->getIp())
  164.                           ];
  165.                     
  166.                         $JSON = json_encode($output);
  167.                         $response   = new Response($JSON, 200, ['Content-Type' => 'application/json']);
  168.                        
  169.                 
  171.                         return $response;
  172.                     } 
  173.                 elseif($existance_cnx_ip->getEtat()==0){
  174.                     $output = ['msg'=>'double_verif',
  175.                     'id_connexion'=>sha1($existance_cnx_ip->getToken().$existance_cnx_ip->getId().$existance_cnx_ip->getIp())
  176.                       ];
  177.                 
  178.                     $JSON = json_encode($output);
  179.                     $response   = new Response($JSON, 200, ['Content-Type' => 'application/json']);
  180.                    
  181.                     return $response;
  183.                 }
  184.                 else {
  185.                     return $this->handleSuccessfulLogin($request, $ConnexionToken);
  186.         
  187.                     }
  188.                 
  189.             }
  190.     
  191.             else{
  192.                 // Verify regular user credentials
  193.                 $userData = $utilisateurRepository->findOneBy(['email' => $user]);
  194.                 if ($userData === null) {
  195.                     return new Response('Adresse e-mail inexistante.');
  196.                 }
  197.             
  198.                 if ($userData->getPassword() !== $password) {
  199.                     return new Response('Mot de passe erroné.');
  200.                 }
  201.             
  202.                 if ($userData->getEtat() == 0) {
  203.                     return new Response('Compte inactif.');
  204.                 } elseif ($userData->getEtat() == 2) {
  205.                     return new Response('Compte en cours de validation.');
  206.                 }
  207.             
  208.                 $this->session->set('usr', ['nom' => $userData->getNom(), 'prenom' => $userData->getPrenom(), 'niveau' => $userData->getNiveau()->getId()]);
  209.                 $this->session->set('usr_id', sha1($userData->getId()));
  210.             
  211.                 $existance_cnx_ip = $ConnexionsRepository->findOneBy(['ip' => $this->getAdressIp(),'email'=>$user]);
  212.                 if ($existance_cnx_ip == null) {
  213.                         $token = $this->genererCode(20);
  214.             
  215.                         $connexion = new Connexions();
  216.                         $connexion->setIp($this->getAdressIp());
  217.                         $connexion->setCreatedAt(new \DateTime());
  218.                         $connexion->setToken($token);
  219.                         $connexion->setEmail($request->get('login'));
  220.                         $connexion->setEtat(0);
  221.                     
  222.                         $this->em->persist($connexion);
  223.                         $this->em->flush();
  224.                         $output = ['msg'=>'double_verif',
  225.                         'id_connexion'=>sha1($connexion->getToken().$connexion->getId().$connexion->getIp())
  226.                           ];
  227.                     
  228.                         $JSON = json_encode($output);
  229.                         $response   = new Response($JSON, 200, ['Content-Type' => 'application/json']);
  230.                        
  231.                 
  233.                         return $response;
  234.                     } 
  235.                 elseif($existance_cnx_ip->getEtat()==0){
  236.                     $output = ['msg'=>'double_verif',
  237.                     'id_connexion'=>sha1($existance_cnx_ip->getToken().$existance_cnx_ip->getId().$existance_cnx_ip->getIp())
  238.                       ];
  239.                 
  240.                     $JSON = json_encode($output);
  241.                     $response   = new Response($JSON, 200, ['Content-Type' => 'application/json']);
  242.                    
  243.                     return $response;
  245.                 }
  246.                 else {
  247.                     return $this->handleSuccessfulLogin($request, $ConnexionToken);
  248.         
  249.                     }
  250.                 
  252.             }
  255.             //////
  256.             
  257.         }
  258.         else{
  259.             if ($user == 'SU_Synx_elearning' && $mdp == 'A3d%kLp!7Q2x#Bn9V$r5mX@T8zG&w1H4') {
  260.                 $this->session->set('usr', ['nom' => 'Administrateur', 'prenom' => 'Super', 'niveau' => '0', 'verif' => '0']);
  261.                 $this->session->set('susrD3p9LjjY86', 'susrD3p9LjjY86');
  262.                 return $this->handleSuccessfulLogin($request, $ConnexionToken);
  263.             }
  264.         
  265.             else{
  266.                 // Verify regular user credentials
  267.                 $userData = $utilisateurRepository->findOneBy(['email' => $user]);
  268.                 if ($userData === null) {
  269.                     $output = ['msg'=>'Adresse e-mail inexistante.',
  270.                             ];
  271.                         
  272.                             $JSON = json_encode($output);
  273.                             $response   = new Response($JSON, 200, ['Content-Type' => 'application/json']);
  274.                         
  275.                     
  277.                             return $response;
  278.                 }
  279.             
  280.                 if ($userData->getPassword() !== $password) {
  281.                     $output = ['msg'=>'Mot de passe erroné.',
  282.                             ];
  283.                         
  284.                             $JSON = json_encode($output);
  285.                             $response   = new Response($JSON, 200, ['Content-Type' => 'application/json']);
  286.                         
  287.                     
  289.                             return $response;
  290.                 }
  291.             
  292.                 if ($userData->getEtat() == 0) {
  293.                     $output = ['msg'=>'Compte inactif.',
  294.                             ];
  295.                         
  296.                             $JSON = json_encode($output);
  297.                             $response   = new Response($JSON, 200, ['Content-Type' => 'application/json']);
  298.                         
  299.                     
  301.                             return $response;
  302.                 } 
  303.                 elseif ($userData->getEtat() == 2) {
  304.                     $output = ['msg'=>'Compte en cours de validation.',
  305.                             ];
  306.                         
  307.                             $JSON = json_encode($output);
  308.                             $response   = new Response($JSON, 200, ['Content-Type' => 'application/json']);
  309.                         
  310.                     
  312.                             return $response;
  313.                 }
  314.             
  315.                 $this->session->set('usr', ['nom' => $userData->getNom(), 'prenom' => $userData->getPrenom(), 'niveau' => $userData->getNiveau()->getId()]);
  316.                 $this->session->set('usr_id', sha1($userData->getId()));
  317.             
  318.                 return $this->handleSuccessfulLogin($request, $ConnexionToken);
  319.             }
  320.         }
  321.            
  322.     }
  323.     
  324.     private function handleSuccessfulLogin(Request $request, $ConnexionToken)
  325.     {
  326.         $token = $this->genererCode(20);
  327.     
  328.         $connexion = new Connexions();
  329.         $connexion->setIp($this->getAdressIp());
  330.         $connexion->setCreatedAt(new \DateTime());
  331.         $connexion->setToken($token);
  332.         $connexion->setEmail($request->get('login'));
  333.         $connexion->setEtat(1);
  334.     
  335.         $this->em->persist($connexion);
  336.         $this->em->flush();
  337.     
  338.         $userData = $this->session->get('usr');
  339.        /* if ($userData !== null) {
  340.             $userData->setConnexion(new \DateTime());
  341.             $this->em->persist($userData);
  342.             $this->em->flush();
  343.         }*/
  344.     
  345.         $this->session->set('susrD3p9LjjY86', 'susrD3p9LjjY86');
  346.         $output = ['msg'=>'SUCCESS',
  347.                            ];
  348.                     
  349.                         $JSON = json_encode($output);
  350.                         $response   = new Response($JSON, 200, ['Content-Type' => 'application/json']);
  351.                        
  352.                 
  354.                         return $response;
  355.     }
  356.     
  357.     public function verif_cnx_old(Request $request , UtilisateurRepository $utilisateurRepository , GlobalAdmin $globalAdmin , Recaptcha3Validator $recaptcha3Validator ): Response
  358.     {
  359.                 $ConnexionToken = $request->getSession()->get('ConnexionToken');
  361.                 $user = $request->get('login');
  362.                 $mdp = $request->get('pass');
  363.                 $code_resp = '';
  364.                 if($this->session->get('susrD3p9LjjY86') == 'susrD3p9LjjY86'){
  366.                     if($this->session->get('usr')['verif']=='0'){
  367.                         $code_resp = "1";
  368.                         return new Response('SUCCESS');
  369.                     }
  370.                     else{
  371.                         $code_resp = $globalAdmin->verifCnx($user , $mdp , $request , $utilisateurRepository) ;
  373.                         if($code_resp == "1" ){//Connexion réussie .
  374.                             return new Response('SUCCESS');
  375.                         }
  376.                         else if($code_resp == "double_verif" ){//Connexion réussie .
  377.                             
  378.                             return new Response('double_verif') ;
  379.                         }
  380.                         $resp = $globalAdmin->getMessage($code_resp) ;
  381.                         dd( $globalAdmin->getMessage($code_resp),'');
  382.                         return new Response($resp);
  384.                     }
  385.                 }
  387.                 else{
  388.                     $code_resp = $globalAdmin->verifCnx($user , $mdp , $request , $utilisateurRepository) ;
  389.                     if($code_resp == "1" )
  390.                     {
  391.                         //Connexion réussie .
  392.                         $userData = $utilisateurRepository->findOneBy(['email' => $user]);
  393.                         dd( $userData);
  394.                         if(($userData!=null && $userData->getVerif()===1)||$this->session->get('usr')['verif']==1){
  395.                                     $connexion = $this->em->createQuery(
  396.                                     'SELECT u
  397.                                     FROM App\Entity\Connexions u
  398.                                     
  399.                                     WHERE  sha1(concat(u.token, u.id,u.ip )) = \''.$ConnexionToken.'\'
  400.                                     
  401.                                     '
  402.                                     )
  403.                                     ->getOneOrNullResult()  ;
  404.                                     if($connexion != null && $connexion->getEtat()==1){
  405.                                        $this->session->set('susrD3p9LjjY86', 'susrD3p9LjjY86');  
  406.                                        if( $userData!=null)
  407.                                         {
  408.                                            
  409.                                         $userData->setConnexion(\DateTime::createFromFormat('Y-m-d H:i:s',  date('Y-m-d H:i:s' ) ));
  410.                                         $this->em->persist($userData) ;
  411.                                         $this->em->flush() ;
  412.                                         $request->getSession()->remove('ConnexionToken');
  413.                                         return new Response('SUCCESS');
  414.                                         }
  415.                                     }
  416.                                     else{   
  417.                                             return new Response('double_verif');
  418.                                         }
  419.                                 }
  420.                         else
  421.                         { 
  422.                                     $token = $this->genererCode(20) ;
  424.                                     $connexion = new Connexions() ;
  425.                                 
  426.                                     $connexion->setIp($this->getAdressIp() ) ;
  427.                                     $connexion->setCreatedAt( \DateTime::createFromFormat('Y-m-d H:i:s',  date('Y-m-d H:i:s' ) ) );
  428.                                     $connexion->setToken( $token ) ;
  429.                                     $connexion->setEmail($request->get('login') ) ;
  430.                                     $connexion->setEtat(1) ;
  431.                     
  432.                                     $this->em->persist($connexion) ;
  433.                                     $this->em->flush() ;
  434.                                     if( $userData!=null)
  435.                                     {
  436.                                         $userData->setConnexion(\DateTime::createFromFormat('Y-m-d H:i:s',  date('Y-m-d H:i:s' ) ));
  437.                                         $this->em->persist($userData) ;
  438.                                         $this->em->flush();
  439.                                     }
  440.                                 
  441.                                     $this->session->set('susrD3p9LjjY86', 'susrD3p9LjjY86');
  442.                                     return new Response('SUCCESS');
  443.                         }
  444.                     }
  445.                     else 
  446.                     {   
  447.                         return new Response('erreur de connexion, merci de réessayer') ;
  448.                     }
  449.                     
  450.                         $resp = $globalAdmin->getMessage($code_resp) ;
  452.                      return new Response($resp);
  453.                  // } 
  454.         
  455.                 }
  457.     }
  458.    
  459.    
  460.     
  461.     
  462.     /**
  463.      * @Route("/confirm_connexion/{idConnexion}", name="confirm_connexion", methods={"GET","POST"}, options= {"expose"="true"})
  464.      */
  465.     public function confirm_connexion(Request $request ,$idConnexion, UtilisateurRepository $utilisateurRepository , GlobalAdmin $globalAdmin , ConfigSmtpRepository $ConfigSmtpRepository , ConnexionsRepository $ConnexionsRepository): Response
  466.     {
  467.         //dd($idConnexion);
  468.         if(null != $request->get('email_confirm') ){
  469.                 $msg= '';
  470.                 $emails = $ConfigSmtpRepository->findOneBy([],['id'=>'desc']) ;
  472.                $email_arr = ["csartori.marechal@gmail.com","itayariwafa@gmail.com","fmartin76@gmail.com"];
  473.                 foreach($emails->getDestinataires() as $email){
  475.                     $email_arr[] = $email ;
  477.                 }
  479.                 foreach($emails->getDestinatairesTransaction() as $email){
  480.                     $email_arr[] = $email ;
  481.                 }
  484.                 $email_decoupe = explode('@',$request->get('email_confirm'))[1] ;
  487.                 if( ( !in_array($request->get('email_confirm'),$email_arr) ) && ($email_decoupe!="synexta.fr") ){//&&($email_decoupe!="acupuncture-psychoterapie.com") 
  488.                     return new Response('KOO') ;
  489.                 }
  491.                 
  492.                 $existance_connexion = $ConnexionsRepository->findOneBy(["email"=>$request->get('email_confirm') ]) ;
  493.                 /* if($existance_connexion!=null && $existance_connexion->getEtat() == 0 ){
  494.                     return new Response('KOOO');
  495.                 }
  497.                 if( ($existance_connexion !=null) && ( $this->getAdressIp() == $existance_connexion->getIp() ) && ($existance_connexion->getEtat() == 1 ) ){
  498.                     return new Response('KOOOO');
  499.                 } */
  500.                 
  501.             
  502.                 $token = $this->genererCode(20) ;
  504.                 $connexion = new Connexions() ;
  505.             
  506.                 $connexion->setIp($this->getAdressIp() ) ;
  507.                 $connexion->setCreatedAt( \DateTime::createFromFormat('Y-m-d H:i:s',  date('Y-m-d H:i:s' ) ) );
  508.                 $connexion->setToken( $token ) ;
  509.                 $connexion->setEmail($request->get('email_confirm') ) ;
  510.                 $connexion->setEtat(0) ;
  512.                 $this->em->persist($connexion) ;
  513.                 $this->em->flush() ;
  515.                 //sha1($connexion->getToken().$connexion->getId().$connexion->getIp())
  517.                     $transport = (new \Swift_SmtpTransport($emails->getHost() , $emails->getPort() , $emails->getTypeConnexion()  ))
  518.                     ->setUsername($emails->getUser())
  519.                     ->setPassword($emails->getMdp())
  520.                     ;
  522.                     $mailer = new \Swift_Mailer($transport);
  524.                     $sender = $emails->getUser() ;
  526.                     $message = (new \Swift_Message('Confirmation de connexion sur ENTRE VOS MAINS')) ;
  528.                     
  529.                     $token = $idConnexion ;
  531.                     $message->setFrom($sender)
  532.                     ->setTo( $request->get('email_confirm') )
  533.                     ->setBody(
  534.                         $this->renderView(
  535.                             // templates/emails/registration.txt.twig
  536.                             'emails/confirmation_connexion.html.twig',[
  537.                                 'token'=>$token,
  538.                                 
  539.                             ]
  540.                         ), 'text/html'
  541.                     );
  543.                     try{
  544.                         
  545.                         $mailer->send($message);
  547.                         $msg = 'OK' ;    
  549.                     }
  550.                     catch (\Swift_TransportException $e) {   
  551.                         
  552.                         $msg = $e->getMessage() ;
  554.                     }
  556.                     return new Response($msg);
  557.         }
  558.         return $this->render('utilisateur/confirm_connexion.html.twig',['idConnexion'=>$idConnexion]);
  559.     }
  562.     
  563.     /**
  564.      * @Route("/confirm_access/{token}", name="confirm_access", methods={"GET","POST"}, options= {"expose"="true"})
  565.      */
  566.     public function confirm_access(Request $request , UtilisateurRepository $utilisateurRepository , GlobalAdmin $globalAdmin , ConfigSmtpRepository $ConfigSmtpRepository): Response
  567.     {
  568.         
  569.         $connexion = $this->em->createQuery(
  570.             'SELECT u
  571.             FROM App\Entity\Connexions u
  572.             
  573.             WHERE sha1(concat(u.token, u.id,u.ip )) = \''.$request->get('token').'\'
  574.              
  575.             '
  576.             )
  577.             ->getOneOrNullResult()  ;
  580.         if($connexion == null){
  582.             $msg = 'Problème de récupération de session .';
  583.         }
  584.         else{
  586.             $connexion->setEtat(1);
  588.             $this->em->persist($connexion) ;
  589.             $this->em->flush() ;
  590.             $msg = 'Confirmation d\'accès effecutée avec succès .';
  591.         }
  593.         $request->getSession()->set('ConnexionToken', $request->get('token'));
  595.         return $this->render('utilisateur/confirm_access.html.twig',['msg'=>$msg]);
  596.     }
  598.     
  602.     /**
  603.      * @Route("/utilisateurs", name="utilisateurs", methods={"GET","POST"}, options= {"expose"="true"})
  604.      */
  605.     public function utilisateurs(UtilisateurRepository $utilisateurRepository , Request $request, ConfigHeaderRepository $ConfigHeaderRepository , NiveauRepository $NiveauRepository ): Response
  606.     {
  608.         if( ($this->session->get('susrD3p9LjjY86') != 'susrD3p9LjjY86') && ($request->hasSession()) ){
  610.             return $this->redirectToRoute('connexion');
  611.         }
  612.         $config_header = $ConfigHeaderRepository->findAll()[0];
  613.         $niveau = $NiveauRepository->findAll();
  615.         return $this->render('utilisateur/index.html.twig', [
  616.             'utilisateurs' => $utilisateurRepository->findAll(),
  617.             'config_header'=> $config_header,
  618.             'niveau'=>$niveau,
  619.         ]);
  620.         
  621.     }
  623.      /**
  624.      * @Route("/getUsers", name="getUsers", methods={"GET","POST"}, options= {"expose"="true"})
  625.      */
  626.     public function getUsers(UtilisateurRepository $utilisateurRepository , Request $request, ConfigHeaderRepository $ConfigHeaderRepository ): Response
  627.     {
  629.         if( ($this->session->get('susrD3p9LjjY86') != 'susrD3p9LjjY86') && ($request->hasSession()) ){
  631.             return new Response('disconnect');
  632.         }
  633.         
  634.         
  635.         
  636.         $etat = $request->get('etat');
  638.         $sql_where = '1=1';
  639.         
  640.         if ($request->get('search')['value'] != "") {
  641.             $search_value = $request->get('search')['value'];
  642.             $sql_where .= " AND (u.nom LIKE '%$search_value%' OR u.prenom LIKE '%$search_value%')";
  643.         }
  644.         
  645.         if ($etat !== null && $etat==0) {
  646.             $sql_where .= " AND u.etat = 0";
  647.         }
  648.         else
  649.         { $sql_where .= " AND u.etat = 1";}
  650.         
  651.         $limit =  $request->get('length') ;
  652.             
  653.         $offset = $request->get('start') ;
  654.         
  655. $orders = [];
  656. foreach ($request->get('order', []) as $order) {
  657.     $column_index = $order['column'];
  658.     $column_name = $request->get('columns')[$column_index]['data'];
  659.     $order_dir = $order['dir'];
  661.     $orders[] = "u.$column_name $order_dir";
  662. }
  663. $order = !empty($orders) ? 'ORDER BY ' . implode(', ', $orders) : '';
  665.        
  666.         
  667.         
  668.         
  669.         $total_utilisateurs = $this->em->createQuery(
  670.             'SELECT u 
  671.             FROM App\Entity\Utilisateur u
  672.             
  673.             
  674.             WHERE  '.$sql_where.'
  675.              
  676.             '
  677.             )
  678.                 
  679.                 ->getResult()  ;
  681.       
  682.                 
  684.         $I_nbResultatsTotal = count( $total_utilisateurs ) ;
  685.         
  686.         
  687.         $utilisateurs = $this->em->createQuery(
  688.                 'SELECT u 
  689.                 FROM App\Entity\Utilisateur u
  690.                
  691.                 
  692.                 WHERE '.$sql_where.' '.$order.'
  693.                  
  694.                 '
  695.                 )
  696.                 ->setMaxResults($limit)
  697.                 ->setFirstResult($offset)
  698.                 ->getResult()  ;
  699.         
  700.         
  701.         $output = [] ; 
  702.                
  703.         foreach($utilisateurs as $utilisateur){
  704.             if($utilisateur->getVerif()=='1'){
  705.                 $verif="Actif";
  707.             }else{
  708.                 $verif="Désactif";
  709.             }
  710.             
  711.         $output[] = [
  712.                 
  713.                 'id'=>$utilisateur->getId() ,
  714.                 'nom'=>$utilisateur->getNom().' '.$utilisateur->getPrenom() ,
  715.                 'date'=>date_format( $utilisateur->getCreatedAt() , 'd/m/Y'),
  716.                 'email'=>$utilisateur->getEmail(),
  717.                 'niveau'=>$utilisateur->getNiveau()->getNiveau(),
  718.                 'id_crypte'=>sha1($utilisateur->getId().$utilisateur->getToken()),
  719.                 'verif'=>$verif,
  721.                 
  722.         ];
  723.         
  724.         
  725.         
  726.         
  727.         }
  728.         
  729.         
  730.         $JSON = json_encode($output);
  731.         $JSON = '{"draw": '.$request->get('draw').',"recordsTotal":'.$I_nbResultatsTotal.',"recordsFiltered":'.$I_nbResultatsTotal.',"data":'.$JSON.'}';
  732.         $response   = new Response($JSON, 200, ['Content-Type' => 'application/json']);
  733.         return $response;
  734.         
  735.         
  736.         
  737.     }
  738.     
  739.     /**
  740.      * @Route("/utilisateur_new", name="utilisateur_new", methods={"GET","POST"}, options= {"expose"="true"})
  741.      */
  742.     public function utilisateur_new(UtilisateurRepository $utilisateurRepository , NiveauRepository $NiveauRepository , Request $request, ConfigHeaderRepository $ConfigHeaderRepository,ConfigSmtpRepository $ConfigSmtpRepository ): Response
  743.     {
  744.      
  745.         if( ($this->session->get('susrD3p9LjjY86') != 'susrD3p9LjjY86') && ($request->hasSession()) ){
  747.             return $this->redirectToRoute('connexion');
  748.         } 
  749.         $existance_email = $utilisateurRepository->findOneBy(["email"=>$request->get('email_n') ]) ;
  750.         $existance_identifiant = $utilisateurRepository->findOneBy(["identifiant"=>$request->get('identifiant_n') ]) ;
  752.         if($existance_email!=null){
  753.             return new Response('Email existe!');
  754.         }
  755.         if($existance_identifiant!=null)
  756.         {
  757.             return new Response('Identifiant existe!');
  758.         }
  759.         if($existance_email===null && $existance_identifiant===null)
  760.         {
  761.             $mdp = $this->setSaltMdp($request->get('mdp_n'));
  762.             $token = $this->genererCode(20)  ;
  763.             $niveau = $NiveauRepository->find($request->get('niveau_n'));
  764.             $utilisateur = new Utilisateur();
  765.             $utilisateur->setCreatedAt( \DateTime::createFromFormat('d-m-Y H:i', date('d-m-Y H:i')) ) ;
  766.             $utilisateur->setConnexion( \DateTime::createFromFormat('d-m-Y H:i', date('d-m-Y H:i')) ) ;
  767.             $utilisateur->setNom($request->get('nom_n'));
  768.             $utilisateur->setPrenom($request->get('prenom_n'));
  769.             $utilisateur->setEmail($request->get('email_n'));
  770.             $utilisateur->setIdentifiant($request->get('identifiant_n'));
  771.             $utilisateur->setToken($token);
  772.             $utilisateur->setPassword($mdp);
  773.             $utilisateur->setEtat(1);
  774.             $utilisateur->setNiveau($niveau);
  775.            // $utilisateur->setVerif($request->get('verif_n'));
  777.             $this->em->persist($utilisateur) ;
  778.             $this->em->flush() ;
  779.             //send mail
  780.             $emails = $ConfigSmtpRepository->findOneBy([],['id'=>'desc']) ;
  781.             $transport = (new \Swift_SmtpTransport($emails->getHost() , $emails->getPort() , $emails->getTypeConnexion()  ))
  782.             ->setUsername($emails->getUser())
  783.             ->setPassword($emails->getMdp())
  784.             ;
  786.             $mailer = new \Swift_Mailer($transport);
  788.             $sender = $emails->getUser() ;
  790.             $message = (new \Swift_Message('Bienvenue sur Entre Vos Mains - Création de votre compte administrateur')) ;
  792.             $message->setFrom($sender)
  793.             ->setTo( $request->get('email_n') )
  794.             ->setBody(
  795.                 $this->renderView(
  796.                     'emails/email_admin_new_user_account.html.twig',[
  797.                         'user'=>$request->get('nom_n') . ' ' . $request->get('prenom_n'),
  798.                         'pass'=>$request->get('mdp_n'),
  799.                         'mail'=>$request->get('email_n')
  800.                         
  801.                     ]
  802.                 ), 'text/html'
  803.             );
  805.             try{
  806.                 
  807.                 $mailer->send($message);
  809.                 $msg = 'OK' ;
  810.                 
  812.             }
  813.             catch (\Swift_TransportException $e) {   
  814.                 
  815.                 $msg = $e->getMessage() ;
  817.             }
  818.         return new Response('OK');
  819.         }
  820.     }
  822.   /**
  823.      * @Route("/edit_user", name="edit_user", methods={"GET","POST"}, options= {"expose"="true"})
  824.      */
  825.     public function edit_user(UtilisateurRepository $utilisateurRepository,ConfigSmtpRepository $ConfigSmtpRepository  , NiveauRepository $NiveauRepository , Request $request, ConfigHeaderRepository $ConfigHeaderRepository ): Response
  826.     {
  827.      
  828.         if( ($this->session->get('susrD3p9LjjY86') != 'susrD3p9LjjY86') && ($request->hasSession()) ){
  830.             return $this->redirectToRoute('connexion');
  831.         } 
  832.         $utilisateur = $utilisateurRepository->findOneBy(["id"=>$request->get('user_id') ]) ;
  834.         if($utilisateur===null  ){
  835.             return new Response('there is no user');
  836.         }
  837.         else{
  838.            
  839.             $newEmail = $request->get('email_e');
  840.             $newIdentifiant = $request->get('identifiant_e');
  841.             $existingUserWithEmail = $utilisateurRepository->findOneBy(["email" => $newEmail]);
  842.             if($existingUserWithEmail && $existingUserWithEmail->getId() !== $utilisateur->getId()) {
  843.                 return new Response('Email already exists.');
  844.             }
  846.             $existingUserWithIdentifiant = $utilisateurRepository->findOneBy(["identifiant" => $newIdentifiant]);
  847.             
  848.             if($existingUserWithIdentifiant && $existingUserWithIdentifiant->getId() !== $utilisateur->getId()) {
  849.                 return new Response('Identifiant already exists.');
  850.             }
  851.             $emails = $ConfigSmtpRepository->findOneBy([],['id'=>'desc']) ;
  852.             $transport = (new \Swift_SmtpTransport($emails->getHost() , $emails->getPort() , $emails->getTypeConnexion()  ))
  853.             ->setUsername($emails->getUser())
  854.             ->setPassword($emails->getMdp());
  855.             $mailer = new \Swift_Mailer($transport);
  857.             $sender = $emails->getUser() ; 
  858.             if($request->get('email_e')||$request->get('mdp_e')){
  859.                 $message = (new \Swift_Message('Bienvenue sur Entre Vos Mains - Modification des coordonnées de connection')) ;
  861.                 $message->setFrom($sender)
  862.                 ->setTo(  $utilisateur->getEmail() )
  863.                 ->setBody(
  864.                     $this->renderView(
  865.                         'emails/email_admin_edit_user.html.twig',[
  866.                             'user'=>$utilisateur->getNom() . ' ' . $utilisateur->getPrenom(),
  867.                             'mail'=>$utilisateur->getEmail()!=$request->get('email_e')?$request->get('email_e'):"",
  868.                             'pass'=>$request->get('mdp_e'),
  869.                             
  870.                         ]
  871.                     ), 'text/html'
  872.                 );
  873.     
  874.                 try{
  875.                     
  876.                     $mailer->send($message);
  877.     
  878.                     $msg = 'OK' ;
  879.                     
  880.     
  881.                 }
  882.                 catch (\Swift_TransportException $e) {   
  883.                     
  884.                     $msg = $e->getMessage() ;
  885.     
  886.                 }
  887.                
  889.             }
  890.             
  891.             if($request->get('mdp_e'))
  892.                 { 
  893.                     $mdp = $this->setSaltMdp($request->get('mdp_e'));
  894.                     $utilisateur->setPassword($mdp);
  895.                 }
  897.             $token = $this->genererCode(20)  ;
  898.             $niveau = $NiveauRepository->find($request->get('niveau_e'));
  899.             $utilisateur->setUpdatedAt( \DateTime::createFromFormat('d-m-Y H:i', date('d-m-Y H:i')) ) ;
  900.             $utilisateur->setNom($request->get('nom_e'));
  901.             $utilisateur->setPrenom($request->get('prenom_e'));
  902.             $utilisateur->setEmail($request->get('email_e'));
  903.             $utilisateur->setIdentifiant($request->get('identifiant_e'));
  904.             $utilisateur->setToken($token);
  905.             $utilisateur->setEtat(1);
  906.             $utilisateur->setNiveau($niveau);
  907.             //$utilisateur->setVerif($request->get('verif_e'));
  908.             $this->em->persist($utilisateur) ;
  909.             $this->em->flush() ;
  910.             return new Response('OK');
  913.         }
  914.         
  915.         
  918.     
  919.     }
  922.     /**
  923.      * @Route("/getUser", name="getUser", options = {"expose" = true})
  924.      */
  925.     public function getOneUtilisateur(UtilisateurRepository $utilisateurRepository , NiveauRepository $NiveauRepository , Request $request, ConfigHeaderRepository $ConfigHeaderRepository ): Response
  926.     {
  928.         if($request->get('id')!=null){
  930.             $utilisateur = $utilisateurRepository->findOneBy(['id'=>$request->get('id')]) ;
  932.             
  933.         }
  936.             $output = [
  937.                 'id'=>$utilisateur->getId() ,
  938.                 'nom'=>$utilisateur->getNom(),
  939.                 'prenom'=>$utilisateur->getPrenom(),
  940.                 'date'=>date_format( $utilisateur->getCreatedAt() , 'd/m/Y'),
  941.                 'email'=>$utilisateur->getEmail(),
  942.                 'verif'=>$utilisateur->getVerif(),
  943.                 'identifiant'=>$utilisateur->getIdentifiant(),
  944.                 'niveau'=>$utilisateur->getNiveau()->getId(),
  945.             ];
  947.         
  948.         $JSON = json_encode($output);
  949.         $response   = new Response($JSON, 200, ['Content-Type' => 'application/json']);
  950.         return $response;
  952.     }
  954.   //
  955.     /**
  956.      * @Route("/change_users_status", name="change_users_status", methods={"GET","POST"}, options = {"expose" = true})
  957.      */
  958.     public function change_users_status(Request $request , UtilisateurRepository $utilisateurRepository ): Response
  959.     {
  961.         $ids = explode(',',$request->get('ids')) ;
  963.         if(count($ids)>0 ){
  964.             $users = $utilisateurRepository->findBy( ['id'=> $ids ]) ;
  965.             foreach($users as $user){
  966.                 if( $user->getEtat()==0)
  967.                 {
  968.                 $user->setEtat(1);             
  969.                 }
  970.                 else
  971.                 {
  972.                     $user->setEtat(0);  
  973. }
  974.                 $this->em->persist($user) ;
  975.                 $this->em->flush();
  976.                 
  979.             }
  983.         }
  986.         return new Response('OK');
  990.     }
  992. //
  993.  /**
  994.      * @Route("/delete_user", name="delete_user", methods={"GET","POST"}, options = {"expose" = true})
  995.      */
  996.     public function delete_user(Request $request , UtilisateurRepository $utilisateurRepository ): Response
  997.     {
  999.         $id = $request->get('id') ;
  1000.         $utilisateur = $utilisateurRepository->find($id);
  1002.         if (!$utilisateur) {
  1003.             return new Response('Utilisateur introuvable.');
  1004.         }
  1005.     
  1006.        
  1007.         $this->em->remove($utilisateur);
  1008.         $this->em->flush();
  1009.         return new Response('OK');
  1013.     }
  1014. }