src/Controller/UtilisateurController.php line 103

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Service\GlobalAdmin;
  6. use App\Service\AdministrateurService;
  8. use App\Entity\Utilisateur;
  9. use App\Entity\ConnexionAdministrateurs ;
  12. use App\Form\UtilisateurType;
  13. use App\Repository\AdministrateursRepository;
  14. use App\Repository\NiveauRepository;
  15. use App\Repository\EtatRepository;
  16. use App\Repository\ConfigSmtpRepository;
  17. use App\Repository\ConnexionAdministrateursRepository;
  21. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  22. use Symfony\Component\HttpFoundation\Request;
  23. use Symfony\Component\HttpFoundation\Response;
  24. use Symfony\Component\Routing\Annotation\Route;
  27. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  28. use Symfony\Component\DependencyInjection\ContainerInterface as Container;
  29. use Doctrine\ORM\EntityManagerInterface;
  31. use Karser\Recaptcha3Bundle\Validator\Constraints\Recaptcha3Validator;
  35. class UtilisateurController extends AbstractController
  36. {
  38.     public function __construct(SessionInterface $session , Container $container , EntityManagerInterface $em )
  39.     {
  40.         
  41.         $this->em = $em ;
  43.         $this->session = $session ;
  45.     }
  48.     function genererCode($length){
  49.         
  50.         $chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
  51.         $string = '';
  52.         for($i=0; $i<$length; $i++){
  53.             $string .= $chars[rand(0, strlen($chars)-1)];
  54.         }
  55.             
  56.         return $string;
  57.             
  58.     }
  60.     private function getAdressIp(){
  62.         $ip_expediteur = '' ;
  63.             
  64.         if(!empty($_SERVER['HTTP_CLIENT_IP'])){
  65.           $ip_expediteur = $_SERVER['HTTP_CLIENT_IP'];
  66.         }elseif(!empty($_SERVER['HTTP_X_FORWARDED_FOR'])){
  67.           $ip_expediteur = $_SERVER['HTTP_X_FORWARDED_FOR'];
  68.         }else{
  69.           $ip_expediteur = $_SERVER['REMOTE_ADDR'];
  70.         }
  73.         return $ip_expediteur ;
  75.     }
  76.     public function generate_mdp($chars) 
  77.     {
  78.     $data = '1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcefghijklmnopqrstuvwxyz';
  79.     return substr(str_shuffle($data), 0, $chars);
  80.     }
  82.     public function setSaltMdp($mdp)
  83.     {
  84.         
  85.         $salt1 ='kgH94zHr927J3zjT4VvC' ;
  86.         $salt2 = 'jA9q52MuFj4u2DxQ9m5X' ;
  87.         
  88.         return sha1($salt1.$mdp.$salt2) ;
  89.         
  90.     }
  91.     
  92.     
  93.  
  100.     /**
  101.      * @Route("/", name="connexion", methods={"GET","POST"} , options={"expose"=true})
  102.      */
  103.     public function connexion(): Response
  104.     {
  105.         return $this->render('utilisateur/connexion.html.twig');
  106.     }
  109.      /**
  110.      * @Route("/deconnexion", name="deconnexion", methods={"GET","POST"})
  111.      */
  112.     public function deconnexion(): Response
  113.     {
  115.         
  117.         $this->session->set('susrD3p9LjjY86', '');
  118.         $this->session->set('supAdT9m2XJzn4','');
  120.         return $this->redirectToRoute('connexion');
  123.         
  124.         
  125.     }
  129.     /**
  130.      * @Route("/login_user", name="login_user", methods={"GET","POST"}, options= {"expose"="true"})
  131.      */
  132.     public function login_user(Request $request , AdministrateursRepository $AdministrateursRepository , GlobalAdmin $globalAdmin , Recaptcha3Validator $recaptcha3Validator ): Response
  133.     {
  135.                 $user = $request->get('login');
  136.                 $mdp = $request->get('pass');
  139.                 $code_resp = '';
  140.                 //dd($this->session->get('susrD3p9LjjY86'));
  141.                 $code_resp = $globalAdmin->verifCnx($user , $mdp , $request , $AdministrateursRepository) ;
  142.                        //dd($code_resp);
  143.                         if($code_resp == "1" ){//Connexion réussie .
  144.                             
  145.                             return new Response('OK');
  146.                             
  147.                         }
  148.                         else if($code_resp == "double_verif" ){//Connexion réussie .
  149.                             
  150.                             return new Response('double_verif') ;
  151.                         }
  152.                         $resp = $globalAdmin->getMessage($code_resp) ;
  153.                         return new Response($resp);    
  154.         
  155.     }
  157.     /**
  158.      * @Route("/verif_cnx", name="verif_cnx", methods={"GET","POST"}, options= {"expose"="true"})
  159.      */
  160.     public function verif_cnx(Request $request , AdministrateursRepository $AdministrateursRepository , GlobalAdmin $globalAdmin , Recaptcha3Validator $recaptcha3Validator ): Response
  161.     {
  163.                 $user = $request->get('login');
  164.                 $mdp = $request->get('pass');
  167.                 $code_resp = '';
  168.                 //dd($this->session->get('susrD3p9LjjY86'));
  169.                 if($this->session->get('susrD3p9LjjY86') == 'gA64ya3G5N'){
  170.                     
  171.                         $code_resp = $globalAdmin->verifCnx($user , $mdp , $request , $AdministrateursRepository) ;
  172.                         //echo($code_resp);
  173.                      
  174.                         if($code_resp == "1" ){//Connexion réussie .
  175.                             $this->session->set('supAdT9m2XJzn4',['nom'=> 'Admin' , 'prenom'=>'Super' ,'email'=>$request->get('login') , 'id'=>'T9m2XJzn4' ]) ;
  177.                             return new Response('OK');
  178.                         }
  179.                         else if($code_resp == "double_verif" ){//Connexion réussie .
  180.                             
  181.                             return new Response('double_verif') ;
  182.                         }
  183.                         $resp = $globalAdmin->getMessage($code_resp) ;
  184.                         return new Response($resp);
  186.                     
  188.                    
  190.                 }
  191.                 else{
  192.                     $code_resp = $globalAdmin->verifCnx($user , $mdp , $request , $AdministrateursRepository) ;
  193.                 
  194.                     if($code_resp == "1" ){//Connexion réussie .
  195.                         $admin = $AdministrateursRepository->findOneBy(['email'=>$user]);
  196.                         if($admin)
  197.                         {
  198.                             $this->session->set('supAdT9m2XJzn4',['nom'=> $admin->getNom() , 'prenom'=>$admin->getPrenom() ,'email'=>$admin->getEmail(), 'id'=>'T9m2XJzn4' ]) ;
  200.                             return new Response('OK');
  201.                         }
  202.                         else{
  203.                             return new Response('KO');
  204.                         }
  205.                     }
  206.                     else if($code_resp == "double_verif" ){//Connexion réussie .
  207.                         
  208.                         return new Response('double_verif') ;
  209.                     }
  210.                     $resp = $globalAdmin->getMessage($code_resp) ;
  212.                 return new Response($resp);
  213.                   
  214.                 
  215.                 }
  216.                 
  217.                 
  218.                 
  221.                 
  223.            
  227.         
  228.         
  229.         
  230.         
  231.     }
  233.      /**
  234.      * @Route("/verif_cnx1", name="verif_cnx1", methods={"GET","POST"}, options= {"expose"="true"})
  235.      */
  236.     public function verif_cnx1(Request $request , AdministrateursRepository $AdministrateursRepository , AdministrateurService $globalAdmin , Recaptcha3Validator $recaptcha3Validator ): Response
  237.     {
  239.                 $user = $request->get('login');
  240.                 $mdp = $request->get('pass');
  241.                 //dd($user , $mdp);
  244.                 $code_resp = '';
  245.                 if($this->session->get('susrD3p9LjjY86') == 'gA64ya3G5N'){
  246.                         $admin = $AdministrateursRepository->findOneBy(['email'=>$user]);
  247.                         if(!$admin){
  248.                             return new Response('Mot de passe ou email incorrecte');
  249.                         }
  250.                         //dd($admin);
  251.                  
  252.                         $code_resp = $globalAdmin->verifCnx($user , $mdp , $request , $admin) ;
  254.                         //dd($code_resp);
  256.                         if($code_resp == "1" ){//Connexion réussie .
  257.                            
  258.                             $this->session->set('supAdT9m2XJzn4',['nom'=> $admin->getNom() , 'prenom'=>$admin->getPrenom() ,'email'=>$admin->getEmail(), 'id'=>'T9m2XJzn4', 'userId' => $admin->getId() ]) ;
  260.                             return new Response('OK');
  261.                         }
  262.                         else if($code_resp == 2 ){//Connexion réussie .
  263.                             
  264.                             return new Response('double_verif') ;
  265.                         }
  266.                         $resp = $globalAdmin->getMessage($code_resp) ;
  268.                         return new Response($resp);
  269.                 }
  270.                 
  271.     }
  274.     
  275.     /**
  276.      * @Route("/confirm_connexion", name="confirm_connexion", methods={"GET","POST"}, options= {"expose"="true"})
  277.      */
  278.     public function confirm_connexion(Request $request, EtatRepository $EtatRepository , AdministrateursRepository $AdministrateursRepository , GlobalAdmin $globalAdmin , ConfigSmtpRepository $ConfigSmtpRepository , ConnexionAdministrateursRepository $ConnexionAdministrateursRepository): Response
  279.     {
  281.         if(null != $request->get('email_confirm') ){
  282.             
  284.             $msg= '';
  287.             $emails = $ConfigSmtpRepository->findOneBy([],['id'=>'desc']) ;
  289.             $email_arr = [];
  290.             foreach($emails->getDestinataires() as $email){
  292.                 $email_arr[] = $email ;
  294.             }
  296.             foreach($emails->getDestinatairesTransaction() as $email){
  297.                 $email_arr[] = $email ;
  298.             }
  301.             $email_decoupe = explode('@',$request->get('email_confirm'))[1] ;
  304.                 if( ( !in_array($request->get('email_confirm'),$email_arr) ) && ($email_decoupe!="synexta.fr") && ($email_decoupe!="synexta-solutions.fr") ){
  305.                     return new Response('KOO') ;
  306.                 }
  307.                 $etat = $EtatRepository->findOneBy(['id'=>2]) ;
  308.                 
  309.                
  311.                 $token = $this->genererCode(20) ;
  312.                 $adminstrateur = $AdministrateursRepository->findOneBy(['email'=>$request->get('email_confirm') ]);
  313.                //verif si j'ai des connexion non actif
  314.                $existance_inactif_cnx = $ConnexionAdministrateursRepository->findBy(['email'=>$request->get('email_confirm'),'etat' => 2]) ;
  315.                if ($existance_inactif_cnx) {
  316.                 
  317.                     foreach ($existance_inactif_cnx as $connexion) {
  318.                         $this->em->remove($connexion);
  319.                     }
  320.                     $this->em->flush();
  321.                 }
  322.             
  323.                 //Ajout connexion
  324.                 $ConnexionAdministrateurs = new ConnexionAdministrateurs() ;
  325.             
  326.                 $ConnexionAdministrateurs->setAdresseIp($this->getAdressIp() ) ;
  327.                 $ConnexionAdministrateurs->setDateConnexion( \DateTime::createFromFormat('Y-m-d H:i:s',  date('Y-m-d H:i:s' ) ) );
  328.                 $ConnexionAdministrateurs->setToken( $token ) ;
  329.                 $ConnexionAdministrateurs->setEmail($request->get('email_confirm') ) ;
  330.                 $ConnexionAdministrateurs->setEtat($etat) ;
  331.                 $ConnexionAdministrateurs->setAdministrateurs($adminstrateur ) ;
  333.                 $this->em->persist($ConnexionAdministrateurs) ;
  334.                 $this->em->flush() ;
  335.                 //nettoyage list des connexions pour gardé que les 3 derniers
  336.                 $existance_cnx = $ConnexionAdministrateursRepository->findBy(['email'=>$request->get('email_confirm')],['date_connexion' => 'DESC']) ;
  337.                  if (count($existance_cnx) > 3) {
  338.                     $connexionsToDelete = array_slice($existance_cnx, 3);
  339.                 
  340.                     foreach ($connexionsToDelete as $connexion) {
  341.                         $this->em->remove($connexion);
  342.                     }
  343.                     $this->em->flush();
  344.                 }
  345.                 
  348.                     $transport = (new \Swift_SmtpTransport($emails->getHost() , $emails->getPort() , $emails->getTypeConnexion()  ))
  349.                     ->setUsername($emails->getUser())
  350.                     ->setPassword($emails->getMdp())
  351.                     ;
  353.                     $mailer = new \Swift_Mailer($transport);
  355.                     $sender = $emails->getUser() ;
  357.                     $message = (new \Swift_Message('Confirmation de connexion sur Dashboard mitih')) ;
  359.                     
  360.                     $token = sha1($token.$ConnexionAdministrateurs->getId().$ConnexionAdministrateurs->getAdresseIp()) ;
  362.                     $message->setFrom($sender)
  363.                     ->setTo( $request->get('email_confirm') )
  364.                     ->setBody(
  365.                         $this->renderView(
  366.                             // templates/emails/registration.txt.twig
  367.                             'emails/confirmation_connexion.html.twig',[
  368.                                 'token'=>$token,
  369.                                 
  370.                             ]
  371.                         ), 'text/html'
  372.                     );
  374.                     try{
  375.                         
  376.                         $mailer->send($message);
  378.                         $msg = 'OK' ;
  379.                         
  381.                     }
  382.                     catch (\Swift_TransportException $e) {   
  383.                         
  384.                         $msg = $e->getMessage() ;
  386.                     }
  389.                     return new Response($msg);
  391.                 
  397.         }
  399.         return $this->render('utilisateur/confirm_connexion.html.twig');
  401.     }
  404.     
  405.     /**
  406.      * @Route("/confirm_access/{token}", name="confirm_access", methods={"GET","POST"}, options= {"expose"="true"})
  407.      */
  408.     public function confirm_access(Request $request, EtatRepository $EtatRepository, ConnexionAdministrateursRepository $ConnexionAdministrateursRepository, AdministrateursRepository $AdministrateursRepository, GlobalAdmin $globalAdmin, ConfigSmtpRepository $ConfigSmtpRepository): Response
  409. {
  410.     $connexion = $this->em->createQuery(
  411.         'SELECT u
  412.         FROM App\Entity\ConnexionAdministrateurs u
  413.         WHERE sha1(concat(u.token, u.id, u.adresse_ip)) = :token'
  414.     )
  415.     ->setParameter('token', $request->get('token'))
  416.     ->getOneOrNullResult();
  417.     $status='';
  418.     if ($connexion === null) {
  419.         $msg = 'Problème de récupération de session.';
  420.         $status='KOO';
  421.     } else {
  422.         $now = new \DateTime();
  423.         $interval = $now->diff($connexion->getDateConnexion());
  425.         // Vérifie si la différence est supérieure à 4 heures
  426.         if ($interval->h >= 4 || $interval->days > 0) {
  427.             // Supprime la connexion si elle a expiré
  428.             $this->em->remove($connexion);
  429.             $this->em->flush();
  431.             $msg = 'Lien expiré. Veuillez vous reconnecter.';
  432.             $status='KOO';
  433.         } else {
  434.             $etat = $EtatRepository->findOneBy(['id' => 1]);
  435.             $connexion->setEtat($etat);
  437.             $this->em->persist($connexion);
  438.             $this->em->flush();
  439.             $status='OK';
  441.             $msg = 'Confirmation d\'accès effectuée avec succès.';
  442.         }
  443.     }
  445.     return $this->render('utilisateur/confirm_access.html.twig', ['status'=>$status,'msg' => $msg]);
  446. }
  447.     public function confirm_access_old(Request $request ,EtatRepository $EtatRepository, ConnexionAdministrateursRepository $ConnexionAdministrateursRepository, AdministrateursRepository $AdministrateursRepository , GlobalAdmin $globalAdmin , ConfigSmtpRepository $ConfigSmtpRepository): Response
  448.     {
  450.         $connexion = $this->em->createQuery(
  451.             'SELECT u
  452.             FROM App\Entity\ConnexionAdministrateurs u
  453.             
  454.             WHERE sha1(concat(u.token, u.id,u.adresse_ip )) = \''.$request->get('token').'\'
  455.              
  456.             '
  457.             )
  458.             ->getOneOrNullResult()  ;
  461.         if($connexion == null){
  463.             $msg = 'Problème de récupération de session .';
  464.         }
  465.         else{
  466.             $etat = $EtatRepository->findOneBy(['indice'=>'1']) ;
  469.             $connexion->setEtat($etat);
  471.             $this->em->persist($connexion);
  472.             $this->em->flush();
  475.             $msg = 'Confirmation d\'accès effecutée avec succès .';
  476.         }
  480.         return $this->render('utilisateur/confirm_access.html.twig',['msg'=>$msg]);
  481.     }
  483.     
  487.     /**
  488.      * @Route("/utilisateurs", name="utilisateurs", methods={"GET","POST"}, options= {"expose"="true"})
  489.      */
  490.     public function utilisateurs(UtilisateurRepository $utilisateurRepository , Request $request, ConfigHeaderRepository $ConfigHeaderRepository , NiveauRepository $NiveauRepository ): Response
  491.     {
  493.         if( ($this->session->get('susrD3p9LjjY86') != 'gA64ya3G5N') && ($request->hasSession()) ){
  495.             return $this->redirectToRoute('connexion');
  496.         }
  497.         $config_header = $ConfigHeaderRepository->findAll()[0];
  498.         $niveau = $NiveauRepository->findAll();
  501.         return $this->render('utilisateur/index.html.twig', [
  502.             'utilisateurs' => $utilisateurRepository->findAll(),
  503.             'config_header'=> $config_header,
  504.             'niveau'=>$niveau,
  505.         ]);
  506.         
  507.     }
  509.      /**
  510.      * @Route("/serverUtilisateurs", name="serverUtilisateurs", methods={"GET","POST"}, options= {"expose"="true"})
  511.      */
  512.     public function serverUtilisateurs(UtilisateurRepository $utilisateurRepository , Request $request, ConfigHeaderRepository $ConfigHeaderRepository ): Response
  513.     {
  515.         if( ($this->session->get('susrD3p9LjjY86') != 'gA64ya3G5N') && ($request->hasSession()) ){
  517.             return new Response('disconnect');
  518.         }
  519.         
  520.         
  521.         
  522.         $sql_where = "" ;
  524.         
  525.         $limit =  $request->get('length') ;
  526.             
  527.         $offset = $request->get('start') ;
  528.         
  529.         $array_search = array();
  530.         
  531.         $columns = ['u.identifiant'] ;
  532.         
  533.         $orders = [] ;
  534.         
  535.         
  536.         for($i=0 ; $i<count($request->get('order')) ;$i++ ){
  537.             
  538.              $orders[] = $columns[ $request->get('order')[$i]['column'] ].' '.$request->get('order')[$i]['dir'] ;
  539.             
  540.         }
  541.         
  542.         
  543.         if( count($orders)>0){
  544.         $order = " ORDER BY ".implode(' , ',$orders) ;
  545.         }
  546.         else{
  547.         $order = "" ;  
  548.         }
  550.         
  551.         
  552.         
  553.         
  554.         $total_utilisateurs = $this->em->createQuery(
  555.             'SELECT u 
  556.             FROM App\Entity\Utilisateur u
  557.             
  558.             
  559.             WHERE 1=1 '.$sql_where.'
  560.              
  561.             '
  562.             )
  563.                 
  564.                 ->getResult()  ;
  566.       
  567.                 
  569.         $I_nbResultatsTotal = count( $total_utilisateurs ) ;
  570.         
  571.         
  572.         $utilisateurs = $this->em->createQuery(
  573.                 'SELECT u 
  574.                 FROM App\Entity\Utilisateur u
  575.                
  576.                 
  577.                 WHERE 1=1 '.$sql_where.' '.$order.'
  578.                  
  579.                 '
  580.                 )
  581.                 ->setMaxResults($limit)
  582.                 ->setFirstResult($offset)
  583.                 ->getResult()  ;
  584.         
  585.         
  586.         $output = [] ; 
  587.                
  588.         foreach($utilisateurs as $utilisateur){
  589.             if($utilisateur->getVerif()=='1'){
  590.                 $verif="Actif";
  592.             }else{
  593.                 $verif="Désactif";
  594.             }
  595.             
  596.         $output[] = [
  597.                 
  598.                 'id'=>$utilisateur->getId() ,
  599.                 'nom'=>$utilisateur->getNom().' '.$utilisateur->getPrenom() ,
  600.                 'date'=>date_format( $utilisateur->getCreatedAt() , 'd/m/Y'),
  601.                 'email'=>$utilisateur->getEmail(),
  602.                 'niveau'=>$utilisateur->getNiveau()->getNiveau(),
  603.                 'id_crypte'=>sha1($utilisateur->getId().$utilisateur->getToken()),
  604.                 'verif'=>$verif,
  606.                 
  607.         ];
  608.         
  609.         
  610.         
  611.         
  612.         }
  613.         
  614.         
  615.         $JSON = json_encode($output);
  616.         $JSON = '{"draw": '.$request->get('draw').',"recordsTotal":'.$I_nbResultatsTotal.',"recordsFiltered":'.$I_nbResultatsTotal.',"data":'.$JSON.'}';
  617.         $response   = new Response($JSON, 200, ['Content-Type' => 'application/json']);
  618.         return $response;
  619.         
  620.         
  621.         
  622.     }
  623.     
  624.     /**
  625.      * @Route("/utilisateur_new", name="utilisateur_new", methods={"GET","POST"}, options= {"expose"="true"})
  626.      */
  627.     public function utilisateur_new(UtilisateurRepository $utilisateurRepository , NiveauRepository $NiveauRepository , Request $request, ConfigHeaderRepository $ConfigHeaderRepository ): Response
  628.     {
  629.      
  630.         if( ($this->session->get('susrD3p9LjjY86') != 'gA64ya3G5N') && ($request->hasSession()) ){
  632.             return $this->redirectToRoute('connexion');
  633.         } 
  634.         $existance_user = $utilisateurRepository->findOneBy(["email"=>$request->get('email_n') ]) ;
  636.         if($existance_user!=null && $existance_user->getEtat() == 0 ){
  637.             return new Response('KO');
  638.         }
  639.         
  640.         $mdp = $this->setSaltMdp($request->get('mdp_n'));
  641.         $token = $this->genererCode(20)  ;
  642.         $niveau = $NiveauRepository->find($request->get('niveau_n'));
  643.         $etat = $EtatRepository->findOneBy(['indice'=>'1']) ;
  645.         $utilisateur = new Utilisateur();
  646.         $utilisateur->setCreatedAt( \DateTime::createFromFormat('d-m-Y H:i', date('d-m-Y H:i')) ) ;
  647.         $utilisateur->setConnexion( \DateTime::createFromFormat('d-m-Y H:i', date('d-m-Y H:i')) ) ;
  648.         $utilisateur->setNom($request->get('nom_n'));
  649.         $utilisateur->setPrenom($request->get('prenom_n'));
  650.         $utilisateur->setEmail($request->get('email_n'));
  651.         $utilisateur->setIdentifiant($request->get('identifiant_n'));
  652.         $utilisateur->setToken($token);
  653.         $utilisateur->setPassword($mdp);
  654.         $utilisateur->setEtat($etat);
  655.         $utilisateur->setNiveau($niveau);
  656.         $utilisateur->setVerif($request->get('verif_n'));
  658.         $this->em->persist($utilisateur) ;
  659.         $this->em->flush() ;
  660.         return new Response('OK');
  664.     
  665.     }
  668.     /**
  669.      * @Route("/getOneUtilisateur", name="getOneUtilisateur", options = {"expose" = true})
  670.      */
  671.     public function getOneUtilisateur(UtilisateurRepository $utilisateurRepository , NiveauRepository $NiveauRepository , Request $request, ConfigHeaderRepository $ConfigHeaderRepository ): Response
  672.     {
  674.         if($request->get('id')!=null){
  676.             $utilisateur = $utilisateurRepository->findOneBy(['id'=>$request->get('id')]) ;
  678.             
  679.         }
  682.             $output = [
  683.                 'id'=>$utilisateur->getId() ,
  684.                 'nom'=>$utilisateur->getNom(),
  685.                 'prenom'=>$utilisateur->getPrenom(),
  686.                 'date'=>date_format( $utilisateur->getCreatedAt() , 'd/m/Y'),
  687.                 'email'=>$utilisateur->getEmail(),
  688.                 'verif'=>$utilisateur->getVerif(),
  689.                 'identifiant'=>$utilisateur->getIdentifiant(),
  690.                 'niveau'=>$utilisateur->getNiveau()->getId(),
  691.             ];
  693.         
  694.         $JSON = json_encode($output);
  695.         $response   = new Response($JSON, 200, ['Content-Type' => 'application/json']);
  696.         return $response;
  698.     }
  700.     /**
  701.      * @Route("/utilisateur_edit", name="utilisateur_edit", methods={"GET","POST"}, options= {"expose"="true"})
  702.      */
  703.     public function utilisateur_edit(UtilisateurRepository $utilisateurRepository , NiveauRepository $NiveauRepository , Request $request, ConfigHeaderRepository $ConfigHeaderRepository ): Response
  704.     {
  705.      
  706.         if( ($this->session->get('susrD3p9LjjY86') != 'gA64ya3G5N') && ($request->hasSession()) ){
  708.             return $this->redirectToRoute('connexion');
  709.         } 
  710.         $existance_user = $utilisateurRepository->findOneBy(["email"=>$request->get('email_n') ]) ;
  712.         if($existance_user!=null && $existance_user->getEtat() == 0 ){
  713.             return new Response('KO');
  714.         }
  715.         
  716.         $mdp = $this->setSaltMdp($request->get('mdp_n'));
  717.         $token = $this->genererCode(20)  ;
  718.         $niveau = $NiveauRepository->find($request->get('niveau_n'));
  719.         $etat = $EtatRepository->findOneBy(['indice'=>'1']) ;
  721.         $utilisateur = new Utilisateur();
  722.         $utilisateur->setCreatedAt( \DateTime::createFromFormat('d-m-Y H:i', date('d-m-Y H:i')) ) ;
  723.         $utilisateur->setConnexion( \DateTime::createFromFormat('d-m-Y H:i', date('d-m-Y H:i')) ) ;
  724.         $utilisateur->setNom($request->get('nom_n'));
  725.         $utilisateur->setPrenom($request->get('prenom_n'));
  726.         $utilisateur->setEmail($request->get('email_n'));
  727.         $utilisateur->setIdentifiant($request->get('identifiant_n'));
  728.         $utilisateur->setToken($token);
  729.         $utilisateur->setPassword($mdp);
  730.         $utilisateur->setEtat($etat);
  731.         $utilisateur->setNiveau($niveau);
  732.         $utilisateur->setVerif($request->get('verif_n'));
  734.         $this->em->persist($utilisateur) ;
  735.         $this->em->flush() ;
  736.         return new Response('OK');
  740.     
  741.     }
  747. }