src/Controller/Controller_Frontoffice/Utilisateur/UtilisateurController.php line 985

  1. <?php
  2. namespace App\Controller\Controller_Frontoffice\Utilisateur;
  3. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  4. use Symfony\Component\HttpFoundation\Response;
  5. use Symfony\Component\Routing\Annotation\Route;
  6. use App\Entity\Commande;
  7. use App\Entity\Membres;
  8. use App\Entity\Newsletter;
  9. use App\Entity\Panier;
  10. use App\Entity\Token;
  11. use App\Entity\Articles;
  12. use App\Entity\CodePromo;
  13. use App\Entity\HistoriquePrixArticle;
  14. use App\Entity\Images;
  15. use App\Entity\Slider;
  16. use App\Entity\SousCategories;
  17. use App\Entity\Entreprise;
  18. use App\Entity\Categories;
  19. use App\Service\SendMailService;
  20. use Doctrine\ORM\EntityManagerInterface;
  21. use Symfony\Component\HttpFoundation\Request;
  22. use Symfony\Bundle\FrameworkBundle\Controller\Controller;
  23. use Symfony\Component\HttpFoundation\Session\Session;
  24. use Symfony\Component\Serializer\Serializer;
  25. use Symfony\Component\Serializer\Normalizer\GetSetMethodNormalizer;
  26. use Symfony\Component\Serializer\Encoder\JsonEncoder;
  27. use Knp\Component\Pager\PaginatorInterface;
  28. use Symfony\Component\Serializer\SerializerInterface;
  29. use KnpU\OAuth2ClientBundle\Client\ClientRegistry;
  30. use Symfony\Component\HttpFoundation\RedirectResponse;
  31. use Symfony\Component\Security\Csrf\CsrfTokenManagerInterface;
  32. class UtilisateurController extends AbstractController
  33. {
  34.     private $clientRegistry;
  35.     public function __construct(ClientRegistry $clientRegistry CsrfTokenManagerInterface $csrfTokenManager,int $length 12)
  36.     {
  37.         $this->clientRegistry $clientRegistry;
  38.         $this->length $length;
  39.         $this->characters '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
  40.         $this->csrfTokenManager $csrfTokenManager;
  41.     }
  42.     #[Route('/connect/google'name'connect_google_start')]
  43.     public function connectGoogle(): RedirectResponse
  44.     {
  45.         return $this->clientRegistry
  46.             ->getClient('google')
  47.             ->redirect([], []);
  48.     }
  49.     #[Route('/connect/google/check'name'connect_google_check')]
  50.     public function connectGoogleCheck(EntityManagerInterface $entityManager): RedirectResponse
  51.     {
  52.         $session = new Session();
  53.         $client $this->clientRegistry->getClient('google');
  54.         $panier = array();
  55.         if($session->get("panier")){
  56.             $panier $session->get("panier");
  57.         }
  58.         try {
  59.             $password '';
  60.             $maxIndex strlen($this->characters) - 1;
  61.             for ($i 0$i $this->length$i++) {
  62.                 $password .= $this->characters[random_int(0$maxIndex)];
  63.             }
  64.             $user $client->fetchUser();
  65.             // Extract information from the GoogleUser object
  66.             $response $user->toArray();
  67.             
  68.             $email $response['email'];
  69.             $prenom $response['given_name'];
  70.             $nom $response['family_name'];
  71.             $fullName $response['name'];
  72.             $profilePicture $response['picture'];
  73.             $emailVerified $response['email_verified'];
  74.             $repository $entityManager->getRepository(Membres::class);
  75.             $membre $repository->findOneBy(array("email"=>$email));
  76.             if(!$membre){
  77.                 // Create new member entity and set its properties
  78.                 $membre = new Membres();
  79.                 $membre->setEtat(1);
  80.                 $membre->setEmail($email);
  81.                 $membre->setAdresse('');
  82.                 $membre->setAdresseComplement('');
  83.                 $membre->setVille('');
  84.                 $membre->setCnss(0);
  85.                 $membre->setCodeType(1);
  86.                 $membre->setDateCreation(new \DateTime());
  87.                 $membre->setIce(0);
  88.                 $membre->setIdentifiantF(0);
  89.                 $membre->setLan(0);
  90.                 $membre->setLat(0);
  91.                 $membre->setNom($prenom);
  92.                 $membre->setPassword(md5($password));
  93.                 $membre->setPattente(0);
  94.                 $membre->setPrenom($nom);
  95.                 $membre->setRc("");
  96.                 //$membre->setRs("");
  97.                 $membre->setTokenId(0);
  98.                 $membre->setType('Particulier');
  99.                 $membre->setTel("");
  100.                 $entityManager->persist($membre);
  101.                 $entityManager->flush();
  102.             
  103.                 //------------ création du panier ----------//
  104.                 if($membre->getEtat() == 1){
  105.                     $commande = new Commande();
  106.                     $commande->setDateCommande(new \DateTime());
  107.                     $commande->setIdMembre($membre->getId());
  108.                     $commande->setTotal(0);
  109.                     $commande->setEtat(0);
  110.                     $commande->setValidationUser(0);
  111.                     $commande->setCodePromo("");
  112.                     $commande->setLivraison(0);
  113.                     $commande->setPromo(0);
  114.                     $entityManager->persist($commande);
  115.                     $entityManager->flush();
  116.                     //-------INITIALISATION DU PANIER--------//
  117.                     
  118.                     $repository $entityManager->getRepository(Commande::class);
  119.                     $commande $repository->findOneBy(array("idMembre"=>$membre->getId(),"validationUser"=>0));
  120.                     if($commande){
  121.                         //-------Ajout de l'ancien panier et du nouveau-------//
  122.                         $repository $entityManager->getRepository(Panier::class);
  123.                         $pan $repository->findBy(array("idCommande"=>$commande->getId()));
  124.                         for($i=0;$i<count($pan);$i++){
  125.                             if (array_key_exists($pan[$i]->getIdArticle(), $panier) == false) {
  126.                                 $panier[$pan[$i]->getIdArticle()] = $pan[$i];
  127.                                 //-----mettre  les articles dans  le petit panier
  128.                                 $repository $entityManager->getRepository(Articles::class);
  129.                                 $t $repository->findOneById($pan[$i]->getIdArticle());
  130.                                 $petitpan[$pan[$i]->getIdArticle()]['produit'] = $t;
  131.                                 $petitpan[$pan[$i]->getIdArticle()]["panier"] = $pan[$i];
  132.                             }
  133.                         }
  134.                         $total 0;
  135.                         foreach ($panier as $p){
  136.                             $repository $entityManager->getRepository(Articles::class);
  137.                             $article $repository->findOneById($p->getIdArticle());
  138.                             if($article){
  139.                                 $q $p->getQte();
  140.                                 $prixU 0;
  141.                                 if($membre->getCodeType() == 1){
  142.                                     $prixU $article->getPrixTTC();
  143.                                     if($article->getPrixPromo() > && $article->getPrixPromo() < $article->getPrixTTC()){
  144.                                         $prixU $article->getPrixPromo();
  145.                                     }
  146.                                 }else{
  147.                                     $prixU $article->getPrixProTTC();
  148.                                     if($article->getPrixPromo() > && $article->getPrixPromo() < $article->getPrixProTTC()){
  149.                                         $prixU $article->getPrixPromo();
  150.                                     }
  151.                                 }
  152.                                 $total $total + ($prixU $q);
  153.                                 $repository $entityManager->getRepository(Panier::class);
  154.                                 $pan $repository->findOneBy(array("idArticle"=>$p->getIdArticle(),"idCommande"=>$commande->getId()));
  155.                                 if($pan){
  156.                                     $pan->setQte($q);
  157.                                     $pan->setPrixU($prixU);
  158.                                     $t $prixU $q;
  159.                                     $pan->setPrixTotal($t);
  160.                                     $entityManager->flush();
  161.                                 }
  162.                                 else{
  163.                                     $t $prixU $q;
  164.                                     $p->setPrixU($prixU);
  165.                                     $p->setPrixTotal($t);
  166.                                     $p->setIdCommande($commande->getId());
  167.                                     $entityManager->persist($p);
  168.                                     $entityManager->flush();
  169.                                 }
  170.                             }
  171.                         }
  172.                         $repository $entityManager->getRepository(Entreprise::class);
  173.                         $entreprise $repository->findOneById(1);
  174.                         $livraison 0;
  175.                         if($total <= $entreprise->getPrixMinCmd() && $total 0){
  176.                             $livraison $entreprise->getFraisLivraison();
  177.                         }
  178.                         if($total $entreprise->getPrixMinCmd2()){
  179.                             $livraison $entreprise->getFraisLivraison2();
  180.                         }
  181.                         $commande->setLivraison($livraison);
  182.                         $commande->setTotal($total);
  183.                         $entityManager->flush();
  184.                         $session->set("panier",$panier);
  185.                         $session->set("connectU","OK");
  186.                         $session->set("userU",$membre);
  187.                         $session->set("commande",$commande->getId());
  188.                     }
  189.                     
  190.                 }
  191.                 else{
  192.                     $response "Votre compte a été créer avec succès, Il sera validé dans les plus brefs délais.";
  193.                 }
  194.                 return $this->redirect("/monProfil");
  195.             }else{
  196.                 $session->set("connectU","OK");
  197.                 $session->set("userU",$membre);
  198.                 return $this->redirect("/monProfil");
  199.             }
  200.         } catch (IdentityProviderException $e) {
  201.             var_dump($e->getMessage());
  202.             return $this->redirectToRoute('/');
  203.         }
  204.     }
  205.     #[Route('/connect/facebook'name'connect_facebook_start')]
  206.     public function connectFacebook(): RedirectResponse
  207.     {
  208.         $session = new Session();
  209.         $state $this->csrfTokenManager->getToken('facebook')->getValue();
  210.         $session->set('oauth2state'$state);
  211.         
  212.         return $this->clientRegistry
  213.             ->getClient('facebook')
  214.             ->redirect([], ['state' => $state]);
  215.     }
  216.     #[Route('/connect/facebook/check'name'connect_facebook_check')]
  217.     public function connectFacebookCheck(EntityManagerInterface $entityManager): RedirectResponse
  218.     {
  219.         $session = new Session();
  220.         
  221.         $client $this->clientRegistry->getClient('facebook');
  222.         $panier = array();
  223.         if($session->get("panier")){
  224.             $panier $session->get("panier");
  225.         }
  226.         
  227.         
  228.         $state $session->get('oauth2state');
  229.            
  230.         if (empty($state)) {
  231.             $session->remove('oauth2state');
  232.             throw new \RuntimeException('Invalid state');
  233.         }
  234.         try {
  235.             $password '';
  236.             $maxIndex strlen($this->characters) - 1;
  237.             for ($i 0$i $this->length$i++) {
  238.                 $password .= $this->characters[random_int(0$maxIndex)];
  239.             }
  240.           
  241.             $user $client->fetchUser();
  242.             $facebookData $user->toArray();
  243.             
  244.    
  245.             $email $facebookData['email'] ?? null;
  246.             $firstName $facebookData['first_name'] ?? null;
  247.             $lastName $facebookData['last_name'] ?? null;
  248.             $profilePicture $facebookData['picture']['data']['url'] ?? null;
  249.             $repository $entityManager->getRepository(Membres::class);
  250.             $membre $repository->findOneBy(array("email"=>$email));
  251.             if(!$membre){
  252.                 // Create new member entity and set its properties
  253.                 $membre = new Membres();
  254.                 $membre->setEtat(1);
  255.                 $membre->setEmail($email);
  256.                 $membre->setAdresse('');
  257.                 $membre->setAdresseComplement('');
  258.                 $membre->setVille('');
  259.                 $membre->setCnss(0);
  260.                 $membre->setCodeType(1);
  261.                 $membre->setDateCreation(new \DateTime());
  262.                 $membre->setIce(0);
  263.                 $membre->setIdentifiantF(0);
  264.                 $membre->setLan(0);
  265.                 $membre->setLat(0);
  266.                 $membre->setNom($lastName);
  267.                 $membre->setPassword(md5($password));
  268.                 $membre->setPattente(0);
  269.                 $membre->setPrenom($firstName);
  270.                 $membre->setRc("");
  271.                 //$membre->setRs("");
  272.                 $membre->setTokenId(0);
  273.                 $membre->setType('Particulier');
  274.                 $membre->setTel("");
  275.                 $entityManager->persist($membre);
  276.                 $entityManager->flush();
  277.             
  278.                 //------------ création du panier ----------//
  279.                 if($membre->getEtat() == 1){
  280.                     $commande = new Commande();
  281.                     $commande->setDateCommande(new \DateTime());
  282.                     $commande->setIdMembre($membre->getId());
  283.                     $commande->setTotal(0);
  284.                     $commande->setEtat(0);
  285.                     $commande->setValidationUser(0);
  286.                     $commande->setCodePromo("");
  287.                     $commande->setLivraison(0);
  288.                     $commande->setPromo(0);
  289.                     $entityManager->persist($commande);
  290.                     $entityManager->flush();
  291.                     //-------INITIALISATION DU PANIER--------//
  292.                     
  293.                     $repository $entityManager->getRepository(Commande::class);
  294.                     $commande $repository->findOneBy(array("idMembre"=>$membre->getId(),"validationUser"=>0));
  295.                     if($commande){
  296.                         //-------Ajout de l'ancien panier et du nouveau-------//
  297.                         $repository $entityManager->getRepository(Panier::class);
  298.                         $pan $repository->findBy(array("idCommande"=>$commande->getId()));
  299.                         for($i=0;$i<count($pan);$i++){
  300.                             if (array_key_exists($pan[$i]->getIdArticle(), $panier) == false) {
  301.                                 $panier[$pan[$i]->getIdArticle()] = $pan[$i];
  302.                                 //-----mettre  les articles dans  le petit panier
  303.                                 $repository $entityManager->getRepository(Articles::class);
  304.                                 $t $repository->findOneById($pan[$i]->getIdArticle());
  305.                                 $petitpan[$pan[$i]->getIdArticle()]['produit'] = $t;
  306.                                 $petitpan[$pan[$i]->getIdArticle()]["panier"] = $pan[$i];
  307.                             }
  308.                         }
  309.                         $total 0;
  310.                         foreach ($panier as $p){
  311.                             $repository $entityManager->getRepository(Articles::class);
  312.                             $article $repository->findOneById($p->getIdArticle());
  313.                             if($article){
  314.                                 $q $p->getQte();
  315.                                 $prixU 0;
  316.                                 if($membre->getCodeType() == 1){
  317.                                     $prixU $article->getPrixTTC();
  318.                                     if($article->getPrixPromo() > && $article->getPrixPromo() < $article->getPrixTTC()){
  319.                                         $prixU $article->getPrixPromo();
  320.                                     }
  321.                                 }else{
  322.                                     $prixU $article->getPrixProTTC();
  323.                                     if($article->getPrixPromo() > && $article->getPrixPromo() < $article->getPrixProTTC()){
  324.                                         $prixU $article->getPrixPromo();
  325.                                     }
  326.                                 }
  327.                                 $total $total + ($prixU $q);
  328.                                 $repository $entityManager->getRepository(Panier::class);
  329.                                 $pan $repository->findOneBy(array("idArticle"=>$p->getIdArticle(),"idCommande"=>$commande->getId()));
  330.                                 if($pan){
  331.                                     $pan->setQte($q);
  332.                                     $pan->setPrixU($prixU);
  333.                                     $t $prixU $q;
  334.                                     $pan->setPrixTotal($t);
  335.                                     $entityManager->flush();
  336.                                 }
  337.                                 else{
  338.                                     $t $prixU $q;
  339.                                     $p->setPrixU($prixU);
  340.                                     $p->setPrixTotal($t);
  341.                                     $p->setIdCommande($commande->getId());
  342.                                     $entityManager->persist($p);
  343.                                     $entityManager->flush();
  344.                                 }
  345.                             }
  346.                         }
  347.                         $repository $entityManager->getRepository(Entreprise::class);
  348.                         $entreprise $repository->findOneById(1);
  349.                         $livraison 0;
  350.                         if($total <= $entreprise->getPrixMinCmd() && $total 0){
  351.                             $livraison $entreprise->getFraisLivraison();
  352.                         }
  353.                         if($total $entreprise->getPrixMinCmd2()){
  354.                             $livraison $entreprise->getFraisLivraison2();
  355.                         }
  356.                         $commande->setLivraison($livraison);
  357.                         $commande->setTotal($total);
  358.                         $entityManager->flush();
  359.                         $session->set("panier",$panier);
  360.                         $session->set("connectU","OK");
  361.                         $session->set("userU",$membre);
  362.                         $session->set("commande",$commande->getId());
  363.                     }
  364.                     
  365.                 }
  366.                 else{
  367.                     $response "Votre compte a été créer avec succès, Il sera validé dans les plus brefs délais.";
  368.                 }
  369.                 return $this->redirect("/monProfil");
  370.             }else{
  371.                 $session->set("connectU","OK");
  372.                 $session->set("userU",$membre);
  373.                 return $this->redirect("/monProfil");
  374.             }
  375.         } catch (IdentityProviderException $e) {
  376.             var_dump($e->getMessage());
  377.             return $this->redirectToRoute('/');
  378.         }
  379.     }
  380.     #[Route('/account'name'account')]
  381.     public function compteAction(EntityManagerInterface $entityManager,Request $request): Response
  382.     {
  383.         $session = new Session();
  384.         if($session->get("connectU") == "OK" && $session->get("userU") != null){
  385.             return $this->redirect("/monProfil/");
  386.         }
  387.         $panier = array();
  388.         if($session->get("panier")){
  389.             $panier $session->get("panier");
  390.         }
  391.         $n count($panier);
  392.         $response "";
  393.         if($request->getMethod() == "POST"){
  394.             $email $request->get("email");
  395.             $password $request->get("password");
  396.             $repository $entityManager->getRepository(Membres::class);
  397.             $membre $repository->findOneBy(array("email"=>$email,"password"=>md5($password)));
  398.             if($membre){
  399.                 if($membre->getEtat() == 0){
  400.                     $response "Votre compte n'est pas actif ! veuillez nous contacter pour avoir plus de details";
  401.                 }
  402.                 else{
  403.                     $session->set("connectU","OK");
  404.                     $session->set("userU",$membre);
  405.                     //-------INITIALISATION DU PANIER--------//
  406.                     
  407.                     $repository $entityManager->getRepository(Commande::class);
  408.                     $commande $repository->findOneBy(array("idMembre"=>$membre->getId(),"validationUser"=>0));
  409.                     if($commande){
  410.                         //-------Ajout de l'ancien panier et du nouveau-------//
  411.                         $repository $entityManager->getRepository(Panier::class);
  412.                         $pan $repository->findBy(array("idCommande"=>$commande->getId()));
  413.                         for($i=0;$i<count($pan);$i++){
  414.                             if (array_key_exists($pan[$i]->getIdArticle(), $panier) == false) {
  415.                                 $panier[$pan[$i]->getIdArticle()] = $pan[$i];
  416.                                 //-----mettre  les articles dans  le petit panier
  417.                                 $repository $entityManager->getRepository(Articles::class);
  418.                                 $t $repository->findOneById($pan[$i]->getIdArticle());
  419.                                 $petitpan[$pan[$i]->getIdArticle()]['produit'] = $t;
  420.                                 $petitpan[$pan[$i]->getIdArticle()]["panier"] = $pan[$i];
  421.                             }
  422.                         }
  423.                         $total 0;
  424.                         foreach ($panier as $p){
  425.                             $repository $entityManager->getRepository(Articles::class);
  426.                             $article $repository->findOneById($p->getIdArticle());
  427.                             if($article){
  428.                                 $q $p->getQte();
  429.                                 $prixU 0;
  430.                                 if($membre->getCodeType() == 1){
  431.                                     $prixU $article->getPrixTTC();
  432.                                     if($article->getPrixPromo() > && $article->getPrixPromo() < $article->getPrixTTC()){
  433.                                         $prixU $article->getPrixPromo();
  434.                                     }
  435.                                 }else{
  436.                                     $prixU $article->getPrixProTTC();
  437.                                     if($article->getPrixPromo() > && $article->getPrixPromo() < $article->getPrixProTTC()){
  438.                                         $prixU $article->getPrixPromo();
  439.                                     }
  440.                                 }
  441.                                 $total $total + ($prixU $q);
  442.                                 $repository $entityManager->getRepository(Panier::class);
  443.                                 $pan $repository->findOneBy(array("idArticle"=>$p->getIdArticle(),"idCommande"=>$commande->getId()));
  444.                                 if($pan){
  445.                                     $pan->setQte($q);
  446.                                     $pan->setPrixU($prixU);
  447.                                     $t $prixU $q;
  448.                                     $pan->setPrixTotal($t);
  449.                                     $entityManager->flush();
  450.                                 }
  451.                                 else{
  452.                                     $t $prixU $q;
  453.                                     $p->setPrixU($prixU);
  454.                                     $p->setPrixTotal($t);
  455.                                     $p->setIdCommande($commande->getId());
  456.                                     $entityManager->persist($p);
  457.                                     $entityManager->flush();
  458.                                 }
  459.                             }
  460.                         }
  461.                         $repository $entityManager->getRepository(Entreprise::class);
  462.                         $entreprise $repository->findOneById(1);
  463.                         $livraison 0;
  464.                         if($total <= $entreprise->getPrixMinCmd() && $total 0){
  465.                             $livraison $entreprise->getFraisLivraison();
  466.                         }
  467.                         if($total $entreprise->getPrixMinCmd2()){
  468.                             $livraison $entreprise->getFraisLivraison2();
  469.                         }
  470.                         $commande->setLivraison($livraison);
  471.                         $commande->setTotal($total);
  472.                         $entityManager->flush();
  473.                         $session->set("panier",$panier);
  474.                         //$session->set("petitpan",$petitpan);
  475.                         $session->set("commande",$commande->getId());
  476.                     }
  477.                     else{
  478.                         $commande = new Commande();
  479.                         $commande->setDateCommande(new \DateTime());
  480.                         $commande->setIdMembre($membre->getId());
  481.                         $commande->setTotal(0);
  482.                         $commande->setEtat(0);
  483.                         $commande->setValidationUser(0);
  484.                         $commande->setCodePromo("");
  485.                         $commande->setLivraison(0);
  486.                         $commande->setPromo(0);
  487.                         $entityManager->persist($commande);
  488.                         $entityManager->flush();
  489.                         $total 0;
  490.                         foreach ($panier as $p) {
  491.                             
  492.                             $repository $entityManager->getRepository(Articles::class);
  493.                             $article $repository->findOneById($p->getIdArticle());
  494.                             if($article){
  495.                                 $q $p->getQte();
  496.                                 $prixU 0;
  497.                                 if($membre->getCodeType() == 1){
  498.                                     $prixU $article->getPrixTTC();
  499.                                     if($article->getPrixPromo() > && $article->getPrixPromo() < $article->getPrixTTC()){
  500.                                         $prixU $article->getPrixPromo();
  501.                                     }
  502.                                 }else{
  503.                                     $prixU $article->getPrixProTTC();
  504.                                     if($article->getPrixPromo() > && $article->getPrixPromo() < $article->getPrixProTTC()){
  505.                                         $prixU $article->getPrixPromo();
  506.                                     }
  507.                                 }
  508.                                 $p->setPrixU($prixU);
  509.                                 $total $total + ($prixU $q);
  510.                                 $p->setPrixTotal($prixU $q);
  511.                                 $p->setIdCommande($commande->getId());
  512.                                 $entityManager->persist($p);
  513.                                 $entityManager->flush();
  514.                             }
  515.                         }
  516.                         $repository $entityManager->getRepository(Entreprise::class);
  517.                         $entreprise $repository->findOneById(1);
  518.                         $livraison 0;
  519.                         if($total <= $entreprise->getPrixMinCmd() && $total 0){
  520.                             $livraison $entreprise->getFraisLivraison();
  521.                         }
  522.                         if($total $entreprise->getPrixMinCmd2()){
  523.                             $livraison $entreprise->getFraisLivraison2();
  524.                         }
  525.                         $commande->setLivraison($livraison);
  526.                         $commande->setTotal($total);
  527.                         $entityManager->flush();
  528.                         $session->set("commande",$commande->getId());
  529.                     }
  530.                     return $this->redirect("/monProfil/");
  531.                 }
  532.             }
  533.             else{
  534.                 $response "Login ou mot de passe incorrect !";
  535.             }
  536.         }
  537.         return $this->render('frontoffice_bundle/utilisateur/compte.html.twig', array('controller_name' => 'UtilisateurController',"response"=>$response,"npanier"=>$n));
  538.     }
  539.     #[Route('/account/new/{type}/'name'account_new')]
  540.     public function inscriptionAction($typeEntityManagerInterface $entityManager,Request $request): Response
  541.     {
  542.         $session = new Session();
  543.         if($session->get("connectU") == "OK" && $session->get("userU") != null){
  544.             return $this->redirect("/monProfil/");
  545.         }
  546.         $panier = array();
  547.         if($session->get("panier")){
  548.             $panier $session->get("panier");
  549.         }
  550.         $n count($panier);
  551.         if($type != "Professionnel" && $type != "Particulier"){
  552.             return $this->redirect("/account/");
  553.         }
  554.         $panier = array();
  555.         if($session->get("panier")){
  556.             $panier $session->get("panier");
  557.         }
  558.         $response "";
  559.         
  560.         if($request->getMethod() == "POST"){
  561.             $nom $request->get("nom");
  562.             $prenom $request->get("prenom");
  563.             $tel $request->get("tel");
  564.             $adresse $request->get("adresse");
  565.             $adresse1 $request->get("complementAdresse");
  566.             $ville $request->get("ville");
  567.             $email $request->get("email");
  568.             $password1 $request->get("password1");
  569.             $password2 $request->get("password2");
  570.             $rs "";
  571.             $rc "";
  572.             $if "";
  573.             $pattente "";
  574.             $cnss "";
  575.             $ice "";
  576.             $etat 1;
  577.             $code 1;
  578.             $this->get_lat_long($adresse." ".$adresse1,$ville);
  579.             $ifAllOk true;
  580.             if(empty($nom) || empty($prenom) || empty($tel) || empty($adresse) || empty($adresse1) || empty($ville) || empty($email) || empty($password1) || empty($password2)){
  581.                 $ifAllOk false;
  582.             }
  583.             if($type == "Professtionnel"){
  584.                 $rs $request->get("rs");
  585.                 $rc $request->get("rc");
  586.                 $if $request->get("if");
  587.                 $pattente $request->get("pattente");
  588.                 $cnss $request->get("cnss");
  589.                 $ice $request->get("ice");
  590.                 $etat 0;
  591.                 $code 2;
  592.                 if(empty($rs) || empty($rc) || empty($if) || empty($pattente) || empty($cnss) || empty($ice)){
  593.                     $ifAllOk false;
  594.                 }
  595.             }
  596.             if($ifAllOk){
  597.                 if (filter_var($emailFILTER_VALIDATE_EMAIL)) {
  598.                     
  599.                     $repository $entityManager->getRepository(Membres::class);
  600.                     $membre $repository->findOneByEmail($email);
  601.                     if($membre){
  602.                         $response "Utilisateur existant dans notre base de données";
  603.                     }
  604.                     else{
  605.                         if(strlen($password1) >= 8){
  606.                             if($password1 == $password2){
  607.                                 
  608.                                 $latlong    =   $this->get_lat_long($adresse." ".$adresse1,$ville);
  609.                                 $map        =   explode(',' ,$latlong);
  610.                                 $mapLat         =   $map[0];
  611.                                 $mapLong    =   $map[1];
  612.                                 $membre = new Membres();
  613.                                 $membre->setEtat($etat);
  614.                                 $membre->setEmail($email);
  615.                                 $membre->setAdresse($adresse1);
  616.                                 $membre->setAdresseComplement($adresse1);
  617.                                 $membre->setVille($ville);
  618.                                 $membre->setCnss($cnss);
  619.                                 $membre->setCodeType($code);
  620.                                 $membre->setDateCreation(new \DateTime());
  621.                                 $membre->setIce($ice);
  622.                                 $membre->setIdentifiantF($if);
  623.                                 $membre->setLan($mapLong);
  624.                                 $membre->setLat($mapLat);
  625.                                 $membre->setNom($nom);
  626.                                 $membre->setPassword(md5($password1));
  627.                                 $membre->setPattente($pattente);
  628.                                 $membre->setPrenom($prenom);
  629.                                 $membre->setRc($rc);
  630.                                 // $membre->setRs($rs);
  631.                                 $membre->setTokenId(0);
  632.                                 $membre->setType($type);
  633.                                 $membre->setTel($tel);
  634.                                 $entityManager->persist($membre);
  635.                                 $entityManager->flush();
  636.                                 //------------ création du panier ----------//
  637.                                 if($etat == 1){
  638.                                     $commande = new Commande();
  639.                                     $commande->setDateCommande(new \DateTime());
  640.                                     $commande->setIdMembre($membre->getId());
  641.                                     $commande->setTotal(0);
  642.                                     $commande->setEtat(0);
  643.                                     $commande->setValidationUser(0);
  644.                                     $commande->setCodePromo("");
  645.                                     $commande->setLivraison(0);
  646.                                     $commande->setPromo(0);
  647.                                     $entityManager->persist($commande);
  648.                                     $entityManager->flush();
  649.                                     $total 0;
  650.                                     foreach ($panier as $p) {
  651.                                         
  652.                                         $repository $entityManager->getRepository(Articles::class);
  653.                                         $article $repository->findOneById($p->getIdArticle());
  654.                                         if($article){
  655.                                             $q $p->getQte();
  656.                                             $prixArticle $article->getPrixTTC();
  657.                                             if($article->getPrixPromo() > && $article->getPrixPromo() < $article->getPrixTTC()){
  658.                                                 $prixArticle $article->getPrixPromo();
  659.                                             }
  660.                                             $p->setPrixU($prixArticle);
  661.                                             $total $total + ($prixArticle $q);
  662.                                             $p->setPrixTotal($prixArticle $q);
  663.                                             $p->setIdCommande($commande->getId());
  664.                                             $entityManager->persist($p);
  665.                                             $entityManager->flush();
  666.                                         }
  667.                                     }
  668.                                     $repository $entityManager->getRepository(Entreprise::class);
  669.                                     $entreprise $repository->findOneById(1);
  670.                                     $livraison 0;
  671.                                     if($total <= $entreprise->getPrixMinCmd() && $total 0){
  672.                                         $livraison $entreprise->getFraisLivraison();
  673.                                     }
  674.                                     if($total $entreprise->getPrixMinCmd2()){
  675.                                         $livraison $entreprise->getFraisLivraison2();
  676.                                     }
  677.                                     $commande->setLivraison($livraison);
  678.                                     $commande->setTotal($total);
  679.                                     $entityManager->flush();
  680.                                     $session->set("connectU""OK");
  681.                                     $session->set("userU"$membre);
  682.                                     $session->set("commande"$commande->getId());
  683.                                     return $this->Redirect('/monProfil/');
  684.                                 }
  685.                                 else{
  686.                                     $response "Votre compte a été créer avec succès, Il sera validé dans les plus brefs délais.";
  687.                                 }
  688.                             }
  689.                             else{
  690.                                 $response "Les deux mots de passe ne sont pas identiques !";
  691.                             }
  692.                         }
  693.                         else{
  694.                             $response "Le mot de passe doit comprendre 8 caractères au minimum !";
  695.                         }
  696.                     }
  697.                 }
  698.                 else{
  699.                     $response "Adresse email invalide !";
  700.                 }
  701.             }
  702.             else{
  703.                 $response "Un des champs est vide !";
  704.             }
  705.         }
  706.         return $this->render('frontoffice_bundle/utilisateur/inscription.html.twig', array('controller_name' => 'UtilisateurController',"npanier"=>$n,"type"=>$type,"response"=>$response));
  707.     }
  708.     private function get_lat_long($address,$ville)
  709.     {
  710.         $address str_replace(" ""+"$address." ".$ville);
  711.         // $json = file_get_contents("http://maps.google.com/maps/api/geocode/json?address=$address&sensor=false&region=$ville&key=AIzaSyCHSOeo1mvoLyLbWUUCqi9jFyu4NCxqk5o");
  712.         $json file_get_contents("https://api.geoapify.com/v1/geocode/search?street=$address&postcode=11000&city=$ville&country=Maroc&format=json&apiKey=1cea42924b5f4366b8919ff4272cff58");
  713.         $json json_decode($json);
  714.         $lat null;
  715.         $long null;
  716.         if(($json->{'results'}[0])){
  717.             $lat $json->{'results'}[0]->{'lat'};
  718.             $long $json->{'results'}[0]->{'lon'};
  719.         }
  720.         
  721.         return $lat.','.$long;
  722.     }
  723.     #[Route('/deconnect'name'deconnect')]
  724.     public function deconnectAction(EntityManagerInterface $entityManager,Request $request): Response
  725.     {
  726.         $session = new Session();
  727.         $session->set("connectU","NO");
  728.         $session->set("userU","");
  729.         return $this->Redirect('/');
  730.     }
  731.     #[Route('/contact'name'contact')]
  732.     public function contactAction(Request $request,SendMailService $sendMailService)
  733.     {
  734.         $session = new Session();
  735.         $destinataire $request->get("email");
  736.         $Sujet $request->get("subject");
  737.         $Message $request->get("message");
  738.         $Prenom $request->get("name");
  739.         $panier = array();
  740.         if($session->get("panier")){
  741.             $panier $session->get("panier");
  742.         }
  743.         $n count($panier);
  744.         
  745.         if($destinataire)
  746.         {
  747.             $sendMailService->sendEmailContact($destinataire$Sujet$Message,$Prenom);
  748.         }
  749.         return $this->render('frontoffice_bundle/utilisateur/contact.html.twig', array("npanier"=>$n));
  750.     }
  751.     #[Route('/updatePassword'name'updatePassword')]
  752.     public function updatepasswordAction(EntityManagerInterface $entityManager,Request $request): Response
  753.     {
  754.         $session = new Session();
  755.         if($session->get("connectU") == "OK" && $session->get("userU") != null){
  756.             return $this->redirect("/monProfil/");
  757.         }
  758.         $panier = array();
  759.         if($session->get("panier")){
  760.             $panier $session->get("panier");
  761.         }
  762.         $n count($panier);
  763.         $response "";
  764.         if($request->getMethod() == "POST"){
  765.             $email $request->get("email");
  766.             if (!filter_var($emailFILTER_VALIDATE_EMAIL)){
  767.                 $response "Adresse email invalide";
  768.             }
  769.             else{
  770.                 
  771.                 $repository $entityManager->getRepository(Membres::class);
  772.                 $us $repository->findOneBy(array("email"=>$email));
  773.                 if($us){
  774.                     $repository $entityManager->getRepository(Token::class);
  775.                     $token $repository->findOneByIdMembre($us->getId());
  776.                     $t "";
  777.                     if($token){
  778.                         $t $token->getToken();
  779.                     }
  780.                     else{
  781.                         $date = new \DateTime();
  782.                         $d date_format($date"Y-m-d H:i");
  783.                         $t md5($us->getEmail().$us->getId().$d);
  784.                         $token = new Token();
  785.                         $token->setToken($t);
  786.                         $token->setEmail($email);
  787.                         $token->setDate(new \DateTime());
  788.                         $token->setIdMembre($us->getId());
  789.                         $entityManager->persist($token);
  790.                         $entityManager->flush();
  791.                     }
  792.                     $to      $email;
  793.                     $subject "Mot de passe oublié";
  794.                     $message "\n";
  795.                     $message $message."Bonjour ".$us->getNom();
  796.                     $message $message." \n\n"."Vous pouvez reinitialiser votre mot de passe en cliquant sur ce lien : http://www.epicerie-rabat.ma/reset/".$t."/?id=".$us->getId();
  797.                     $message $message." \n\n\n\n"."Epicerie de Rabat : ";
  798.                     $entetedate  date("D, j M Y H:i:s -0600");
  799.                     $headers 'From: support@epicerie-rabat.ma '"\n";
  800.                     $headers $headers."Date: ".$entetedate." \n";
  801.                     if(mail($to$subject$message$headers)){
  802.                         $response "OK";
  803.                     }
  804.                     else{
  805.                         $response "NO";
  806.                     }
  807.                 }
  808.                 else{
  809.                     $response "Cette adresse email ne figure pas dans notre base de données";
  810.                 }
  811.             }
  812.         }
  813.         return $this->render('frontoffice_bundle/utilisateur/updatepassword.html.twig',  array("response"=>$response,"npanier"=>$n));
  814.     }
  815. }