src/Controller/Front/UserController.php line 67

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Front;
  5. use App\Entity\Document;
  6. use App\Entity\User;
  7. use App\Mail\Mail;
  8. use App\Repository\AddressRepository;
  9. use App\Repository\DocumentRepository;
  10. use App\Repository\UserRepository;
  11. use App\Service\ActivityService;
  12. use App\Service\GlobalVariables;
  13. use App\Service\RightService;
  14. use Doctrine\DBAL\Exception;
  15. use Doctrine\ORM\EntityManagerInterface;
  16. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  17. use Symfony\Component\HttpFoundation\JsonResponse;
  18. use Symfony\Component\HttpFoundation\Request;
  19. use Symfony\Component\HttpFoundation\Response;
  20. use Symfony\Component\Messenger\MessageBusInterface;
  21. use Symfony\Component\Messenger\Stamp\DelayStamp;
  22. use Symfony\Component\Security\Core\Encoder\UserPasswordEncoderInterface;
  23. use Symfony\Component\Routing\Annotation\Route;
  26. /**
  27.  * @Route("/client")
  28.  */
  29. class UserController extends AbstractController
  30. {
  32.     // Keys for encryption
  33.     private const ENCRYPTION_KEY = 'nb689fgnf23vic54dfmg21n872121fdf3hpbd212gbn36ed87yxwa89jmspcyf87';
  34.     private const SALT_KEY = 'sunshine-elegance';
  36.     private $addressRepository;
  37.     private $userRepository;
  38.     private $documentRepository;
  39.     private $rightService;
  40.     private $activityService;
  41.     private $globalVariables;
  42.     /** @var EntityManagerInterface */
  43.     private $em;
  45.     public function __construct(
  46.         AddressRepository      $addressRepository,
  47.         UserRepository         $userRepository,
  48.         DocumentRepository     $documentRepository,
  49.         RightService           $rightService,
  50.         ActivityService        $activityService,
  51.         EntityManagerInterface $manager,
  52.         GlobalVariables        $globalVariables
  53.     )
  54.     {
  55.         $this->addressRepository = $addressRepository;
  56.         $this->userRepository = $userRepository;
  57.         $this->documentRepository = $documentRepository;
  58.         $this->rightService = $rightService;
  59.         $this->activityService = $activityService;
  60.         $this->em = $manager;
  61.         $this->globalVariables = $globalVariables;
  62.     }
  64.     /**
  65.      * @Route("/login", name="user_login", methods={"GET"})
  66.      */
  67.     public function login(Request $request): Response
  68.     {
  69.         $message = $request->query->get('message');
  70.         if ($this->getUser()) {
  71.             return $this->redirectToRoute('user_account');
  72.         } else {
  73.             return $this->render('front/user/login.html.twig', compact('message'));
  74.         }
  75.     }
  77.     /**
  78.      * @Route("/account", name="user_account", methods={"GET"}, options={"expose"=true})
  79.      */
  80.     public function account(): Response
  81.     {
  82.         return ($this->getUser())? $this->render('front/user/account.html.twig'):$this->redirectToRoute('user_login');
  83.     }
  85.     /**
  86.      * @Route("/api/get_documents", name="api_get_documents", options={"expose"=true}, methods={"GET"})
  87.      */
  88.     public function getDocumentsAPI(Request $request): Response
  89.     {
  90.         // Vérifier si utilisateur connecté
  91.         if (!$this->globalVariables->timeout()) {
  92.             $response = [
  93.                 'res' => 'ERROR_CNX',
  94.                 'message' => 'Session has ended.',
  95.             ];
  96.             return new jsonResponse($response);
  97.         };
  99.         $page = $request->query->get('page');
  100.         $orderBy = $request->query->get('orderBy');
  102.         // get the product repository
  103.         $documents = $this->em->getRepository(Document::class);
  105.         // build the query for the doctrine paginator
  106.         $query = $documents->createQueryBuilder('d')
  107.             ->where('d.client = :user')
  108.             ->setParameter('user', $this->getUser());
  109.         /*->setParameter('minPrice', $minPrice);*/
  111.         // Order by
  112.         switch ($orderBy) {
  113.             case 1:
  114.                 $query->orderBy('d.createdAt', 'ASC');
  115.                 break;
  116.             case 2:
  117.                 $query->orderBy('d.createdAt', 'DESC');
  118.                 break;
  119.             case 3:
  120.                 $query->orderBy('d.id', 'ASC');
  121.                 break;
  122.             case 4:
  123.                 $query->orderBy('d.id', 'DESC');
  124.                 break;
  126.             case 5:
  127.                 $query->orderBy('d.totalAmountTtc', 'ASC');
  128.                 break;
  130.             case 6:
  131.                 $query->orderBy('d.totalAmountTtc', 'DESC');
  132.                 break;
  134.         }
  136.         $query->getQuery();
  139.         // set page size
  140.         $pageSize = $request->query->get('pageSize');
  142.         // load doctrine Paginator
  143.         $paginator = new \Doctrine\ORM\Tools\Pagination\Paginator($query);
  146.         // you can get total items
  147.         $totalItems = count($paginator);
  150.         // get total pages
  151.         $pagesCount = ceil($totalItems / $pageSize);
  153.         // now get one page's items:
  154.         $paginator
  155.             ->getQuery()
  156.             ->setFirstResult($pageSize * ($page - 1)) // set the offset
  157.             ->setMaxResults($pageSize); // set the limit
  160.         $data = array();
  161.         foreach ($paginator as $pageItem) {
  162.             // do stuff with results...
  163.             array_push($data, $pageItem);
  164.         }
  166.         // Les nombres de pages
  167.         $pages = array();
  168.         for ($i = max($page - 3, 1); $i <= min($page + 3, $pagesCount); $i++) {
  169.             array_push($pages, $i);
  170.         }
  172.         $response = [
  173.             'res' => 'OK',
  174.             'data' => $data,
  175.             'pagesCount' => $pagesCount,
  176.             'total' => $totalItems,
  177.             'pages' => $pages,
  178.             'message' => 'Commandes récupérés avec succès.',
  179.         ];
  180.         return new jsonResponse($response);
  181.     }
  183.     /**
  184.      * @Route("/api/get_document_status", name="api_get_document_status", options={"expose"=true}, methods={"GET"})
  185.      */
  186.     public function getStatusAPI(Request $request): Response
  187.     {
  188.         // Vérifier si utilisateur connecté
  189.         if (!$this->globalVariables->timeout()) {
  190.             $response = [
  191.                 'res' => 'ERROR_CNX',
  192.                 'message' => 'Session has ended.',
  193.             ];
  194.             return new jsonResponse($response);
  195.         };
  197.         $id = $request->query->get('id');
  199.         // get the product repository
  200.         $document = $this->em->getRepository(Document::class)->find($id);
  202.         if (!$document) {
  203.             $response = [
  204.                 'res' => 'ERROR',
  205.                 'message' => 'Aucune commande trouvée.',
  206.             ];
  207.         } else {
  208.             $response = [
  209.                 'res' => 'OK',
  210.                 'data' => $document->getConditionDocument(),
  211.                 'message' => 'Commandes récupérés avec succès.',
  212.             ];
  213.         }
  214.         return new jsonResponse($response);
  215.     }
  217.     /**
  218.      * @Route("/api/get_user_adress", name="api_get_user_adress", options={"expose"=true}, methods={"GET"})
  219.      */
  220.     public function getUserAdressAPI(Request $request): Response
  221.     {
  222.         // Vérifier si utilisateur connecté
  223.         if (!$this->globalVariables->timeout()) {
  224.             $response = [
  225.                 'res' => 'ERROR_CNX',
  226.                 'message' => 'Session has ended.',
  227.             ];
  228.         } else {
  229.             $response = [
  230.                 'res' => 'OK',
  231.                 'data' => [$this->getUser()->getAdress()],
  232.                 'message' => 'Adresses récupérés avec succès.',
  233.             ];
  234.         }
  236.         return new jsonResponse($response);
  237.     }
  239.     /**
  240.      * @Route("/api/save_user_adress", name="api_save_user_adress", options={"expose"=true}, methods={"POST"})
  241.      */
  242.     public function saveUserAdressAPI(Request $request): Response
  243.     {
  244.         // Vérifier si utilisateur connecté
  245.         if (!$this->globalVariables->timeout()) {
  246.             $response = [
  247.                 'res' => 'ERROR_CNX',
  248.                 'message' => 'Session has ended.',
  249.             ];
  250.         } else {
  251.             $adresses = json_decode($request->request->get('adresses'), true);
  252.             $type = json_decode($request->request->get('type'), true);
  254.             // Vérifier si l'adresse est vide
  255.             if ($adresses[$type] == '') {
  256.                 $response = [
  257.                     'res' => 'ERROR',
  258.                     'message' => "L'adresse " . ($type + 1) . " ne doît pas être vide.",
  259.                 ];
  260.             } else {
  261.                 $user = $this->getUser();
  262.                 switch ($type) {
  263.                     case 0:
  264.                         $user->setAdress($adresses[$type]);
  265.                         break;
  266.                     case 1:
  267.                         $user->setSecondAdress($adresses[$type]);
  268.                         break;
  269.                 }
  271.                 $this->em->persist($user);
  272.                 $this->em->flush();
  274.                 $response = [
  275.                     'res' => 'OK',
  276.                     'data' => [$this->getUser()->getAdress()],
  277.                     'message' => 'Adresse modifiée avec succès.',
  278.                 ];
  279.             }
  280.         }
  282.         return new jsonResponse($response);
  283.     }
  285.     /**
  286.      * @Route("/api/get_user_details", name="api_get_user_details", options={"expose"=true}, methods={"GET"})
  287.      */
  288.     public function getUserDetailsAPI(Request $request): Response
  289.     {
  290.         // Vérifier si utilisateur connecté
  291.         if (!$this->globalVariables->timeout()) {
  292.             $response = [
  293.                 'res' => 'ERROR_CNX',
  294.                 'message' => 'Session has ended.',
  295.             ];
  296.         } else {
  297.             $response = [
  298.                 'res' => 'OK',
  299.                 'data' => $this->getUser(),
  300.                 'message' => 'Détails récupérés avec succès.',
  301.             ];
  302.         };
  304.         return new jsonResponse($response);
  305.     }
  307.     /**
  308.      * @Route("/api/save_user_details", name="api_save_user_details", options={"expose"=true}, methods={"POST"})
  309.      */
  310.     public function saveUserDetailsAPI(Request $request, UserPasswordEncoderInterface $passwordEncoder): Response
  311.     {
  313.         if (!$this->globalVariables->timeout()) {
  314.             $response = [
  315.                 'res' => 'ERROR_CNX',
  316.                 'message' => 'Session has ended.',
  317.             ];
  318.         } else {
  319.             $user = json_decode($request->request->get('user'), true);
  320.             $userByMail = $this->em->getRepository(User::class)->findOneBy(array('email' => $user['email']));
  322.             // Vérifier si l'adresse est vide
  323.            
  324.             if ($user['firstName'] == '') {
  325.                 $response = [
  326.                     'res' => 'ERROR',
  327.                     'message' => "Le prénom est obligatoire",
  328.                 ];
  329.             } elseif ($user['email'] == '') {
  330.                 $response = [
  331.                     'res' => 'ERROR',
  332.                     'message' => "L'adresse mail est obligatoire",
  333.                 ];
  334.             } elseif (!filter_var($user['email'], FILTER_VALIDATE_EMAIL)) {
  335.                 $response = [
  336.                     'res' => 'ERROR',
  337.                     'message' => "L'adresse mail n'est pas valide",
  338.                 ];
  339.             } elseif ($userByMail && $userByMail->getId() <> $this->getUser()->getId()) {
  340.                 $response = [
  341.                     'res' => 'ERROR',
  342.                     'message' => "E-mail déja utilisé.",
  343.                 ];
  344.             } elseif (strlen($user['password']) < 6 && strlen($user['password']) > 0) {
  345.                 $response = [
  346.                     'res' => 'ERROR',
  347.                     'message' => "La longueur de mot de passe doît être supérieur à 5",
  348.                 ];
  349.             } elseif (!$passwordEncoder->isPasswordValid($this->getUser(), $user['password']) && strlen($user['password']) > 0) {
  350.                 $response = [
  351.                     'res' => 'ERROR',
  352.                     'message' => "Le mot de passe ne correspond pas",
  353.                 ];
  354.             } elseif (strlen($user['newPassword']) == 0 && strlen($user['password']) > 0) {
  355.                 $response = [
  356.                     'res' => 'ERROR',
  357.                     'message' => "Saisir le nouveau mot de passe",
  358.                 ];
  359.             } elseif (strlen($user['confirmPassword']) == 0 && strlen($user['password']) > 0) {
  360.                 $response = [
  361.                     'res' => 'ERROR',
  362.                     'message' => "Saisir la confirmaion de mot de passe",
  363.                 ];
  364.             } elseif (strlen($user['newPassword']) < 6 && strlen($user['newPassword']) > 0 && strlen($user['password']) > 0) {
  365.                 $response = [
  366.                     'res' => 'ERROR',
  367.                     'message' => "La longueur de nouveau mot de passe doît être supérieur à 5",
  368.                 ];
  369.             } elseif (strlen($user['confirmPassword']) < 6 && strlen($user['confirmPassword']) > 0 && strlen($user['password']) > 0) {
  370.                 $response = [
  371.                     'res' => 'ERROR',
  372.                     'message' => "La longueur de confirmation mot de passe doît être supérieur à 5",
  373.                 ];
  374.             } elseif ($user['newPassword'] != $user['confirmPassword'] && strlen($user['password']) > 0) {
  375.                 $response = [
  376.                     'res' => 'ERROR',
  377.                     'message' => "La confirmation de nouveau mot de passe ne correspond pas",
  378.                 ];
  379.             } else {
  380.                 $this->getUser()->setFirstName($user['firstName']);
  381.                 $this->getUser()->setEmail($user['email']);
  383.                 if (strlen($user['newPassword']) > 0 && $passwordEncoder->isPasswordValid($this->getUser(), $user['password']) && strlen($user['password']) > 0) {
  384.                     $this->getUser()->setPassword(
  385.                         $passwordEncoder->encodePassword(
  386.                             $this->getUser(),
  387.                             $user['newPassword']
  388.                         )
  389.                     );
  390.                 };
  392.                 $this->em->persist($this->getUser());
  393.                 $this->em->flush();
  395.                 $response = [
  396.                     'res' => 'OK',
  397.                     'data' => $this->getUser(),
  398.                     'message' => 'Enregsitrement effectué avec succès.',
  399.                 ];
  400.             }
  402.         }
  404.         return new jsonResponse($response);
  405.     }
  407.     /**
  408.      * @Route("/document/{id}", name="document_details", methods={"GET"}, options={"expose"=true})
  409.      */
  410.     public function document(Request $request, $id): Response
  411.     {
  412.         $max = isset($_ENV['FREE_DELIVERY_AMOUNT']) ? floatval($_ENV['FREE_DELIVERY_AMOUNT']) : 0; // Maximum pour avoir une livraison gratuite
  413.         if ($this->getUser()) {
  414.             $document = $this->em->getRepository(Document::class)->find($id);
  415.             // Vérifier l'existance de la commande
  416.             if (!$document) {
  417.                 return $this->redirectToRoute('user_account');
  418.             }
  420.             return $this->render('front/user/order.html.twig', compact('document', 'max'));
  421.         } else {
  422.             return $this->redirectToRoute('user_login');
  423.         }
  425.     }
  427.     // Functions to encrypt and decrypt a string
  428.     public function encrypt($string, $salt = null): ?string
  429.     {
  430.         // Concaténer la chaine avec la date en cours
  431.         $string = $string . '|' . (new \DateTime('now'))->format('Y-m-d H:i:s');
  432.         if ($salt === null) {
  433.             $salt = hash('sha256', uniqid(mt_rand(), true));
  434.         }  // this is an unique salt per entry and directly stored within a password
  435.         return base64_encode(openssl_encrypt($string, 'AES-256-CBC', self::ENCRYPTION_KEY, 0, str_pad(substr(self::SALT_KEY, 0, 16), 16, '0', STR_PAD_LEFT)))/*.':'.self::SALT_KEY*/ ;
  436.     }
  438.     public function decrypt($string): ?string
  439.     {
  440.         //if( count(explode(':', $string)) !== 2 ) { return $string; }
  441.         //$salt = explode(":",$string)[1];
  442.         //$string = explode(":",$string)[0]; // read salt from entry
  443.         return openssl_decrypt(base64_decode($string), 'AES-256-CBC', self::ENCRYPTION_KEY, 0, str_pad(substr(self::SALT_KEY, 0, 16), 16, '0', STR_PAD_LEFT));
  444.     }
  446.     /**
  447.      * @Route("/account-activation/{key}", name="account_activation", methods={"GET"}, options={"expose"=true})
  448.      */
  449.     public function activateAccount(Request $request, $key): Response
  450.     {
  451.         $string = $this->decrypt($key);
  453.         $parts = explode('|', $string);
  454.         // Récupérer le nom utilisateur
  455.         $username = $parts[0];
  456.         // Récupérer la date d'inscription
  457.         $dateSignUp = $parts[1];
  459.         $date = strtotime('now');
  460.         $dateSignUp = strtotime($dateSignUp);
  462.         // Vérifier si le lien a expiré (envoyé depuis plus de 30 minutes)
  463.         if (round(abs($date - $dateSignUp) / 60, 2) > 30) {
  464.             return $this->render('front/user/login.html.twig', array(
  465.                 'message' => 'Votre lien a expiré. Merci de réassayer.',
  466.             ));
  467.         }
  468.         // Activation du compte et redirection vers la page login
  469.         $user = $this->em->getRepository(User::class)->findOneBy(array('username' => $username));
  470.         // Vérification existance utiliateur
  471.         if (!$user) {
  472.             return $this->render('front/user/login.html.twig', array(
  473.                 'message' => "Votre nom d'utilisateur n'existe pas.",
  474.             ));
  475.         }
  477.         // Vérification existance utiliateur
  478.         if ($user->isVerified()) {
  479.             return $this->render('front/user/login.html.twig', array(
  480.                 'message' => "Votre compte est déjà vérifié. Merci de connecter.",
  481.             ));
  482.         }
  484.         // Activation
  485.         $user->setIsVerified(true);
  487.         // Enregistrement
  488.         $this->em->persist($user);
  489.         $this->em->flush();
  491.         return $this->render('front/user/login.html.twig', array(
  492.             'message' => "Votre compte a été vérifié. Merci de connecter.",
  493.         ));
  494.     }
  496.     /**
  497.      * @Route("/password-restore/{key}", name="password_restore", methods={"GET"}, options={"expose"=true})
  498.      */
  499.     public function restorePassword(Request $request, $key): Response
  500.     {
  501.         $string = $this->decrypt($key);
  503.         $parts = explode('|', $string);
  504.         // Récupérer l'email
  505.         $email = $parts[0];
  506.         // Récupérer la date
  507.         $dateRestore = $parts[1];
  509.         $date = strtotime('now');
  510.         $dateRestore = strtotime($dateRestore);
  512.         // Vérifier si le lien a expiré (envoyé depuis plus de 30 minutes)
  513.         if (round(abs($date - $dateRestore) / 60, 2) > 30) {
  514.             return $this->render('front/user/login.html.twig', array(
  515.                 'message' => 'Votre lien a expiré. Merci de réassayer.',
  516.             ));
  517.         }
  518.         // Activation du compte et redirection vers la page login
  519.         $user = $this->em->getRepository(User::class)->findOneBy(array('email' => $email));
  520.         // Vérification existance utiliateur
  521.         if (!$user) {
  522.             return $this->render('front/user/login.html.twig', array(
  523.                 'message' => "Votre email n'existe pas.",
  524.             ));
  525.         }
  527.         return $this->render('front/user/password.html.twig', array(
  528.             'message' => "Saisir votre nouvelle mot de passe.",
  529.             'key' => $key
  530.         ));
  531.     }
  533.     /**
  534.      * @Route("/api/user_signup", name="api_user_signup", options={"expose"=true}, methods={"POST"})
  535.      */
  536.     public function userSignUpAPI(Request $request, UserPasswordEncoderInterface $passwordEncoder, MessageBusInterface $bus): Response
  537.     {
  538.         $client = json_decode($request->request->get('client'), true);
  540.         // Vérifier les saisies obligatoires
  541.         if ($client['nom'] == '') {
  542.             $response = [
  543.                 'res' => 'ERROR',
  544.                 'message' => "Le nom est obligatoire",
  545.             ];
  546.         } elseif ($client['prenom'] == '') {
  547.             $response = [
  548.                 'res' => 'ERROR',
  549.                 'message' => "Le prénom est obligatoire",
  550.             ];
  551.         } /*elseif ($client['username'] == '') {
  552.             $response = [
  553.                 'res' => 'ERROR',
  554.                 'message' => "Le nom d'utilisateur est obligatoire",
  555.             ];
  556.         } */elseif ($client['telephone'] == '') {
  557.             $response = [
  558.                 'res' => 'ERROR',
  559.                 'message' => "Le numéro de téléphone est obligatoire",
  560.             ];
  561.         } elseif ($client['email'] == '') {
  562.             $response = [
  563.                 'res' => 'ERROR',
  564.                 'message' => "L'adresse mail est obligatoire",
  565.             ];
  566.         } elseif (!filter_var($client['email'], FILTER_VALIDATE_EMAIL)) {
  567.             $response = [
  568.                 'res' => 'ERROR',
  569.                 'message' => "L'adresse mail n'est pas valide",
  570.             ];
  571.         } elseif (strlen($client['password']) == 0) {
  572.             $response = [
  573.                 'res' => 'ERROR',
  574.                 'message' => "Le mot de passe est obligatoire",
  575.             ];
  576.         } elseif (strlen($client['password']) < 6 && strlen($client['password']) > 0) {
  577.             $response = [
  578.                 'res' => 'ERROR',
  579.                 'message' => "La longueur de mot de passe doît être supérieur à 5",
  580.             ];
  581.         } elseif (strlen($client['confirmPassword']) == 0) {
  582.             $response = [
  583.                 'res' => 'ERROR',
  584.                 'message' => "Saisir la confirmaion de mot de passe",
  585.             ];
  586.         } elseif (strlen($client['confirmPassword']) < 6 && strlen($client['confirmPassword']) > 0) {
  587.             $response = [
  588.                 'res' => 'ERROR',
  589.                 'message' => "La longueur de confirmation mot de passe doît être supérieur à 5",
  590.             ];
  591.         } elseif ($client['password'] != $client['confirmPassword']) {
  592.             $response = [
  593.                 'res' => 'ERROR',
  594.                 'message' => "La confirmation de mot de passe ne correspond pas",
  595.             ];
  596.         } elseif (!$client['accept']) {
  597.             $response = [
  598.                 'res' => 'ERROR',
  599.                 'message' => "Veuillez accepter les termes et la politique",
  600.             ];
  601.         } else {
  602.             // Vérification de l'existance de client
  603.             $userByPhone = $this->em->getRepository(User::class)->findOneBy(array('phone' => str_replace(' ', '', $client['telephone'])));
  604. //            $userByUsername = $this->em->getRepository(User::class)->findOneBy(array('username' => $client['username']));
  605.             $userByUsername = $this->em->getRepository(User::class)->findOneBy(array('username' => $client['email']));
  606.             $userByMail = $this->em->getRepository(User::class)->findOneBy(array('email' => $client['email']));
  607.             //$userAll = $this->em->getRepository(User::class)->findOneBy(array('email' => $client['email'], 'phone' => str_replace(' ', '', $client['telephone']), 'username' => $client['username'], 'isVerified' => 0));
  608.             $userAll = $this->em->getRepository(User::class)->findOneBy(array('email' => $client['email'], 'phone' => str_replace(' ', '', $client['telephone']), 'username' => $client['email'], 'isVerified' => 0));
  609.             if ($userAll) {
  610.                 $response = [
  611.                     'res' => 'ERROR',
  612.                     'message' => "Ce compte existe mais n'est pas vérifié.",
  613.                 ];
  614.             } elseif ($userByPhone) {
  615.                 $response = [
  616.                     'res' => 'ERROR',
  617.                     'message' => "Numéro de téléphone déja utilisé.",
  618.                 ];
  619.             } elseif ($userByUsername) {
  620.                 $response = [
  621.                     'res' => 'ERROR',
  622.                     //'message' => "Nom d'utilisateur déja utilisé.",
  623.                     'message' => "E-mail déja utilisé.",
  624.                 ];
  625.             } elseif ($userByMail) {
  626.                 $response = [
  627.                     'res' => 'ERROR',
  628.                     'message' => "E-mail déja utilisé.",
  629.                 ];
  630.             } else {
  631.                 // Suspend auto commit : début de la transaction
  632.                 $this->em->getConnection()->beginTransaction();
  633.                 try {
  634.                     // Création de nouveau utiliateur
  635.                     $user = new User();
  636.                     $user->setType('client');
  637.                     $user->setUsername($client['email']);
  638.                     $user->setFirstName($client['nom']);
  639.                     //$user->setCity($client['civilite']);
  640.                     $user->setPhone(str_replace('', '', $client['telephone']));
  641.                     $user->setEmail($client['email']);
  642.                     $user->setCreatedAt(new \DateTime('now'));
  643.                     $user->setCivility($client['civilite']);
  644.                     // Mot de passe
  645.                     $user->setPassword(
  646.                         $passwordEncoder->encodePassword(
  647.                             $user,
  648.                             $client['password']
  649.                         )
  650.                     );
  651.                     // Enregistrer le nouveau client
  652.                     $this->em->persist($user);
  653.                     $this->em->flush();
  655.                     // Génération de chaine de username crypté
  656.                     $key = $this->encrypt($user->getUsername());
  658.                     // Envoi de mail
  659.                     if (isset($_ENV['MAILER_DSN']) && isset($_ENV['MAILER_MAIL'])) {
  660.                         if ($user->getEmail() && filter_var($user->getEmail(), FILTER_VALIDATE_EMAIL)) {
  661.                             $bus->dispatch(new Mail('front/mail/activation.html.twig', null, $key, $user->getEmail(), 'Activation compte SUNSHINE-ELEGANCE'), [new DelayStamp(10000)]);
  662.                         }
  663.                     };
  664.                     // Try and commit the transaction
  665.                     $this->em->getConnection()->commit();
  666.                 } catch (Exception $e) {
  667.                     // Rollback the failed transaction
  668.                     $this->em->getConnection()->rollBack();
  669.                     throw $e;
  670.                 }
  671.                 $response = [
  672.                     'res' => 'OK',
  673.                     'message' => 'Votre compte a été crée avec succès. Consulter votre boite mail pour activer votre compte.',
  674.                 ];
  675.             }
  677.         }
  679.         return new jsonResponse($response);
  680.     }
  682.     /**
  683.      * @Route("/user-request-password", name="user_request_password", methods={"GET"})
  684.      */
  685.     public function requestPassword(Request $request): Response
  686.     {
  687.         return $this->render('front/user/requestPassword.html.twig');
  688.     }
  690.     /**
  691.      * @Route("/user-request-verify", name="user_request_verify", methods={"GET"})
  692.      */
  693.     public function requestVerify(Request $request): Response
  694.     {
  695.         return $this->render('front/user/requestVerify.html.twig');
  696.     }
  697.     /**
  698.      * @Route("/api/user-change-password", name="api_user_change_password", options={"expose"=true}, methods={"POST"})
  699.      */
  700.     public function changePasswordAPI(Request $request, UserPasswordEncoderInterface $passwordEncoder, MessageBusInterface $bus): Response
  701.     {
  702.         $client = json_decode($request->request->get('client'), true);
  704.         // Vérifier les saisies obligatoires
  705.         if (strlen($client['password']) == 0) {
  706.             $response = [
  707.                 'res' => 'ERROR',
  708.                 'message' => "Saisir votre nouveau passe",
  709.             ];
  710.         } elseif (strlen($client['password']) < 6 && strlen($client['password']) > 0) {
  711.             $response = [
  712.                 'res' => 'ERROR',
  713.                 'message' => "La longueur de mot de passe doît être supérieur à 5",
  714.             ];
  715.         } elseif (strlen($client['confMotDePasse']) == 0) {
  716.             $response = [
  717.                 'res' => 'ERROR',
  718.                 'message' => "Saisir la confirmaion de mot de passe",
  719.             ];
  720.         } elseif (strlen($client['confMotDePasse']) < 6 && strlen($client['confMotDePasse']) > 0) {
  721.             $response = [
  722.                 'res' => 'ERROR',
  723.                 'message' => "La longueur de confirmation mot de passe doît être supérieur à 5",
  724.             ];
  725.         } elseif ($client['password'] != $client['confMotDePasse']) {
  726.             $response = [
  727.                 'res' => 'ERROR',
  728.                 'message' => "La confirmation de mot de passe ne correspond pas",
  729.             ];
  730.         } else {
  731.             $string = $this->decrypt($client['key']);
  733.             $parts = explode('|', $string);
  734.             // Récupérer le nom utilisateur
  735.             $email = $parts[0];
  736.             // Récupérer la date d'inscription
  737.             $dateRestore = $parts[1];
  739.             $date = strtotime('now');
  740.             $dateRestore = strtotime($dateRestore);
  742.             // Vérifier si le lien a expiré (envoyé depuis plus de 30 minutes)
  743.             if (round(abs($date - $dateRestore) / 60, 2) > 30) {
  744.                 return $this->render('front/user/login.html.twig', array(
  745.                     'message' => 'Votre lien a expiré. Merci de réassayer.',
  746.                 ));
  747.             }
  748.             // Activation du compte et redirection vers la page login
  749.             $user = $this->em->getRepository(User::class)->findOneBy(array('email' => $email));
  750.             // Vérification existance utiliateur
  751.             if (!$user) {
  752.                 return $this->render('front/user/login.html.twig', array(
  753.                     'message' => "Votre nom d'utilisateur n'existe pas.",
  754.                 ));
  755.             }
  757.             // Mot de passe
  758.             $user->setPassword(
  759.                 $passwordEncoder->encodePassword(
  760.                     $user,
  761.                     $client['password']
  762.                 )
  763.             );
  765.             // Enregistrement
  766.             $this->em->persist($user);
  767.             $this->em->flush();
  769.             /*return $this->render('front/user/login.html.twig', array(
  770.                 'message' => "Votre compte a été vérifié. Merci de connecter.",
  771.             ));*/
  773.             $response = [
  774.                 'res' => 'OK',
  775.                 'message' => 'Votre mote de passe a été réinitialisé avec succès.',
  776.             ];
  777.         }
  778.         return new jsonResponse($response);
  779.     }
  781.     /**
  782.      * @Route("/email-test", name="email_test", options={"expose"=true}, methods={"GET"})
  783.      */
  784.     public function emailTest(Request $request, MessageBusInterface $bus): Response
  785.     {
  786.         $document = $this->em->getRepository(Document::class)->find(26119);
  787.         // send mail
  788.         $bus->dispatch(new Mail('front/mail/order.html.twig', $document), [new DelayStamp(10000)]);
  790.         $response = [
  791.             'res' => 'Ok',
  792.             'message' => 'Email envoyé.',
  793.         ];
  794.         return new jsonResponse($response);
  795.     }
  797.     /**
  798.      * @Route("/api/user-request-password", name="api_user_request_password", options={"expose"=true}, methods={"POST"})
  799.      */
  800.     public function requestPasswordAPI(Request $request, UserPasswordEncoderInterface $passwordEncoder, MessageBusInterface $bus): Response
  801.     {
  802.         $client = json_decode($request->request->get('client'), true);
  804.         // Vérifier les saisies obligatoires
  805.         if ($client['email'] == '') {
  806.             $response = [
  807.                 'res' => 'ERROR',
  808.                 'message' => "L'adresse mail est obligatoire",
  809.             ];
  810.         } elseif (!filter_var($client['email'], FILTER_VALIDATE_EMAIL)) {
  811.             $response = [
  812.                 'res' => 'ERROR',
  813.                 'message' => "L'adresse mail n'est pas valide",
  814.             ];
  815.         } else {
  816.             // Vérification de l'existance de client
  817.             // $userByUsername = $this->em->getRepository(User::class)->findOneBy(array('username' => $client['email']));
  818.             $userByMail = $this->em->getRepository(User::class)->findOneBy(array('email' => $client['email']));
  819.             /*if (!$userByUsername) {
  820.                 $response = [
  821.                     'res' => 'ERROR',
  822.                     'message' => "Nom d'utilisateur inexistant.",
  823.                 ];
  824.             } */
  825.             if (!$userByMail) {
  826.                 $response = [
  827.                     'res' => 'ERROR',
  828.                     'message' => "E-mail inexistant.",
  829.                 ];
  830.             } else {
  831.                 // Suspend auto commit : début de la transaction
  832.                 $this->em->getConnection()->beginTransaction();
  833.                 try {
  834.                     // Génération de chaine de username crypté
  835.                     $key = $this->encrypt($userByMail->getEmail());
  836.                     // Envoi de mail
  837.                     if (isset($_ENV['MAILER_DSN']) && isset($_ENV['MAILER_MAIL'])) {
  838.                         if ($client['email'] && filter_var($client['email'], FILTER_VALIDATE_EMAIL)) {
  839.                             $bus->dispatch(new Mail('front/mail/password.html.twig', null, $key, $userByMail->getEmail(), 'Réinitialisation mot de passe'), [new DelayStamp(10000)]);
  840.                         }
  841.                     };
  842.                     // Try and commit the transaction
  843.                     $this->em->getConnection()->commit();
  844.                 } catch (Exception $e) {
  845.                     // Rollback the failed transaction
  846.                     $this->em->getConnection()->rollBack();
  847.                     throw $e;
  848.                 }
  849.                 $response = [
  850.                     'res' => 'OK',
  851.                     'message' => 'Un e-mail de réinitialisation de mot de passe vous a été envoyé. Merci de consulter votre boite mail.',
  852.                 ];
  853.             }
  854.         }
  855.         return new jsonResponse($response);
  856.     }
  858.     /**
  859.      * @Route("/api/user_request_verify", name="api_user_request_verify", options={"expose"=true}, methods={"POST"})
  860.      */
  861.     public function requestUserVerifyAPI(Request $request, UserPasswordEncoderInterface $passwordEncoder, MessageBusInterface $bus): Response
  862.     {
  863.         $client = json_decode($request->request->get('client'), true);
  865.         // Vérifier les saisies obligatoires
  866.         if ($client['email'] == '') {
  867.             $response = [
  868.                 'res' => 'ERROR',
  869.                 'message' => "L'adresse mail est obligatoire",
  870.             ];
  871.         } elseif (!filter_var($client['email'], FILTER_VALIDATE_EMAIL)) {
  872.             $response = [
  873.                 'res' => 'ERROR',
  874.                 'message' => "L'adresse mail n'est pas valide",
  875.             ];
  876.         } else {
  877.             // Vérification de l'existance de client
  878.             // $userByUsername = $this->em->getRepository(User::class)->findOneBy(array('username' => $client['email']));
  879.             $userByMail = $this->em->getRepository(User::class)->findOneBy(array('email' => $client['email']));
  880.             /*if (!$userByUsername) {
  881.                 $response = [
  882.                     'res' => 'ERROR',
  883.                     'message' => "Nom d'utilisateur inexistant.",
  884.                 ];
  885.             } */
  886.             if (!$userByMail) {
  887.                 $response = [
  888.                     'res' => 'ERROR',
  889.                     'message' => "E-mail inexistant.",
  890.                 ];
  891.             } else {
  892.                 // Suspend auto commit : début de la transaction
  893.                 $this->em->getConnection()->beginTransaction();
  894.                 try {
  895.                     // Génération de chaine de username crypté
  896.                     $key = $this->encrypt($userByMail->getUsername());
  897.                     // Envoi de mail
  898.                     if (isset($_ENV['MAILER_DSN']) && isset($_ENV['MAILER_MAIL'])) {
  899.                         if ($client['email'] && filter_var($client['email'], FILTER_VALIDATE_EMAIL)) {
  900.                             $bus->dispatch(new Mail('front/mail/activation.html.twig', null, $key, $userByMail->getEmail(), 'Activation compte SUNSHINE-ELEGANCE'), [new DelayStamp(10000)]);
  901.                         }
  902.                     };
  903.                     // Try and commit the transaction
  904.                     $this->em->getConnection()->commit();
  905.                 } catch (Exception $e) {
  906.                     // Rollback the failed transaction
  907.                     $this->em->getConnection()->rollBack();
  908.                     throw $e;
  909.                 }
  910.                 $response = [
  911.                     'res' => 'OK',
  912.                     'message' => 'Un e-mail de vérification vous a été envoyé. Merci de consulter votre boite mail.',
  913.                 ];
  914.             }
  915.         }
  916.         return new jsonResponse($response);
  917.     }
  919.     /**
  920.      * @Route("/api/user_contact", name="api_user_contact", options={"expose"=true}, methods={"POST"})
  921.      */
  922.     public function userContactAPI(Request $request, UserPasswordEncoderInterface $passwordEncoder, MessageBusInterface $bus): Response
  923.     {
  924.         $client = json_decode($request->request->get('client'), true);
  926.         // Vérifier les saisies obligatoires
  927.         if ($client['telephone'] == '') {
  928.             $response = [
  929.                 'res' => 'ERROR',
  930.                 'message' => "Le numéro de téléphone est obligatoire.",
  931.             ];
  932.         } elseif ($client['email'] != '' && !filter_var($client['email'], FILTER_VALIDATE_EMAIL)) {
  933.             $response = [
  934.                 'res' => 'ERROR',
  935.                 'message' => "L'adresse mail n'est pas valide.",
  936.             ];
  938.         } elseif ($client['message'] == '') {
  939.             $response = [
  940.                 'res' => 'ERROR',
  941.                 'message' => "Saisir votre message.",
  942.             ];
  943.         } else {
  944.             // Envoi de mail
  945.             if (isset($_ENV['MAILER_DSN']) && isset($_ENV['MAILER_MAIL']) && isset($_ENV['MAILER_CONTACT'])) {
  946.                 if (filter_var($_ENV['MAILER_CONTACT'], FILTER_VALIDATE_EMAIL)) {
  947.                     $bus->dispatch(new Mail('front/mail/contact.html.twig', null, null, $_ENV['MAILER_CONTACT'], 'Message client contact', $client), [new DelayStamp(10000)]);
  948.                 }
  949.             };
  950.             $response = [
  951.                 'res' => 'OK',
  952.                 'message' => 'Votre message a été envoyé avec succès.'
  953.             ];
  954.         }
  955.         return new jsonResponse($response);
  956.     }
  958. }