src/Controller/Front/UserController.php line 694

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(), $this->getUser()->getSecondAdress()],
  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(), $this->getUser()->getSecondAdress()],
  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.             if ($user['lastName'] == '') {
  324.                 $response = [
  325.                     'res' => 'ERROR',
  326.                     'message' => "Le nom est obligatoire",
  327.                 ];
  328.             } elseif ($user['firstName'] == '') {
  329.                 $response = [
  330.                     'res' => 'ERROR',
  331.                     'message' => "Le prénom est obligatoire",
  332.                 ];
  333.             } elseif ($user['email'] == '') {
  334.                 $response = [
  335.                     'res' => 'ERROR',
  336.                     'message' => "L'adresse mail est obligatoire",
  337.                 ];
  338.             } elseif (!filter_var($user['email'], FILTER_VALIDATE_EMAIL)) {
  339.                 $response = [
  340.                     'res' => 'ERROR',
  341.                     'message' => "L'adresse mail n'est pas valide",
  342.                 ];
  343.             } elseif ($userByMail && $userByMail->getId() <> $this->getUser()->getId()) {
  344.                 $response = [
  345.                     'res' => 'ERROR',
  346.                     'message' => "E-mail déja utilisé.",
  347.                 ];
  348.             } elseif (strlen($user['password']) < 6 && strlen($user['password']) > 0) {
  349.                 $response = [
  350.                     'res' => 'ERROR',
  351.                     'message' => "La longueur de mot de passe doît être supérieur à 5",
  352.                 ];
  353.             } elseif (!$passwordEncoder->isPasswordValid($this->getUser(), $user['password']) && strlen($user['password']) > 0) {
  354.                 $response = [
  355.                     'res' => 'ERROR',
  356.                     'message' => "Le mot de passe ne correspond pas",
  357.                 ];
  358.             } elseif (strlen($user['newPassword']) == 0 && strlen($user['password']) > 0) {
  359.                 $response = [
  360.                     'res' => 'ERROR',
  361.                     'message' => "Saisir le nouveau mot de passe",
  362.                 ];
  363.             } elseif (strlen($user['confirmPassword']) == 0 && strlen($user['password']) > 0) {
  364.                 $response = [
  365.                     'res' => 'ERROR',
  366.                     'message' => "Saisir la confirmaion de mot de passe",
  367.                 ];
  368.             } elseif (strlen($user['newPassword']) < 6 && strlen($user['newPassword']) > 0 && strlen($user['password']) > 0) {
  369.                 $response = [
  370.                     'res' => 'ERROR',
  371.                     'message' => "La longueur de nouveau mot de passe doît être supérieur à 5",
  372.                 ];
  373.             } elseif (strlen($user['confirmPassword']) < 6 && strlen($user['confirmPassword']) > 0 && strlen($user['password']) > 0) {
  374.                 $response = [
  375.                     'res' => 'ERROR',
  376.                     'message' => "La longueur de confirmation mot de passe doît être supérieur à 5",
  377.                 ];
  378.             } elseif ($user['newPassword'] != $user['confirmPassword'] && strlen($user['password']) > 0) {
  379.                 $response = [
  380.                     'res' => 'ERROR',
  381.                     'message' => "La confirmation de nouveau mot de passe ne correspond pas",
  382.                 ];
  383.             } else {
  384.                 $this->getUser()->setFirstName($user['firstName']);
  385.                 $this->getUser()->setLastName($user['lastName']);
  386.                 $this->getUser()->setEmail($user['email']);
  388.                 if (strlen($user['newPassword']) > 0 && $passwordEncoder->isPasswordValid($this->getUser(), $user['password']) && strlen($user['password']) > 0) {
  389.                     $this->getUser()->setPassword(
  390.                         $passwordEncoder->encodePassword(
  391.                             $this->getUser(),
  392.                             $user['newPassword']
  393.                         )
  394.                     );
  395.                 };
  397.                 $this->em->persist($this->getUser());
  398.                 $this->em->flush();
  400.                 $response = [
  401.                     'res' => 'OK',
  402.                     'data' => $this->getUser(),
  403.                     'message' => 'Enregsitrement effectué avec succès.',
  404.                 ];
  405.             }
  407.         }
  409.         return new jsonResponse($response);
  410.     }
  412.     /**
  413.      * @Route("/document/{id}", name="document_details", methods={"GET"}, options={"expose"=true})
  414.      */
  415.     public function document(Request $request, $id): Response
  416.     {
  417.         $max = isset($_ENV['FREE_DELIVERY_AMOUNT']) ? floatval($_ENV['FREE_DELIVERY_AMOUNT']) : 0; // Maximum pour avoir une livraison gratuite
  418.         if ($this->getUser()) {
  419.             $document = $this->em->getRepository(Document::class)->find($id);
  420.             // Vérifier l'existance de la commande
  421.             if (!$document) {
  422.                 return $this->redirectToRoute('user_account');
  423.             }
  425.             return $this->render('front/user/order.html.twig', compact('document', 'max'));
  426.         } else {
  427.             return $this->redirectToRoute('user_login');
  428.         }
  430.     }
  432.     // Functions to encrypt and decrypt a string
  433.     public function encrypt($string, $salt = null): ?string
  434.     {
  435.         // Concaténer la chaine avec la date en cours
  436.         $string = $string . '|' . (new \DateTime('now'))->format('Y-m-d H:i:s');
  437.         if ($salt === null) {
  438.             $salt = hash('sha256', uniqid(mt_rand(), true));
  439.         }  // this is an unique salt per entry and directly stored within a password
  440.         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*/ ;
  441.     }
  443.     public function decrypt($string): ?string
  444.     {
  445.         //if( count(explode(':', $string)) !== 2 ) { return $string; }
  446.         //$salt = explode(":",$string)[1];
  447.         //$string = explode(":",$string)[0]; // read salt from entry
  448.         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));
  449.     }
  451.     /**
  452.      * @Route("/account-activation/{key}", name="account_activation", methods={"GET"}, options={"expose"=true})
  453.      */
  454.     public function activateAccount(Request $request, $key): Response
  455.     {
  456.         $string = $this->decrypt($key);
  458.         $parts = explode('|', $string);
  459.         // Récupérer le nom utilisateur
  460.         $username = $parts[0];
  461.         // Récupérer la date d'inscription
  462.         $dateSignUp = $parts[1];
  464.         $date = strtotime('now');
  465.         $dateSignUp = strtotime($dateSignUp);
  467.         // Vérifier si le lien a expiré (envoyé depuis plus de 30 minutes)
  468.         if (round(abs($date - $dateSignUp) / 60, 2) > 30) {
  469.             return $this->render('front/user/login.html.twig', array(
  470.                 'message' => 'Votre lien a expiré. Merci de réassayer.',
  471.             ));
  472.         }
  473.         // Activation du compte et redirection vers la page login
  474.         $user = $this->em->getRepository(User::class)->findOneBy(array('usermane' => $username));
  475.         // Vérification existance utiliateur
  476.         if (!$user) {
  477.             return $this->render('front/user/login.html.twig', array(
  478.                 'message' => "Votre nom d'utilisateur n'existe pas.",
  479.             ));
  480.         }
  482.         // Vérification existance utiliateur
  483.         if ($user->isVerified()) {
  484.             return $this->render('front/user/login.html.twig', array(
  485.                 'message' => "Votre compte est déjà vérifié. Merci de connecter.",
  486.             ));
  487.         }
  489.         // Activation
  490.         $user->setIsVerified(true);
  492.         // Enregistrement
  493.         $this->em->persist($user);
  494.         $this->em->flush();
  496.         return $this->render('front/user/login.html.twig', array(
  497.             'message' => "Votre compte a été vérifié. Merci de connecter.",
  498.         ));
  499.     }
  501.     /**
  502.      * @Route("/password-restore/{key}", name="password_restore", methods={"GET"}, options={"expose"=true})
  503.      */
  504.     public function restorePassword(Request $request, $key): Response
  505.     {
  506.         $string = $this->decrypt($key);
  508.         $parts = explode('|', $string);
  509.         // Récupérer l'email
  510.         $email = $parts[0];
  511.         // Récupérer la date
  512.         $dateRestore = $parts[1];
  514.         $date = strtotime('now');
  515.         $dateRestore = strtotime($dateRestore);
  517.         // Vérifier si le lien a expiré (envoyé depuis plus de 30 minutes)
  518.         if (round(abs($date - $dateRestore) / 60, 2) > 30) {
  519.             return $this->render('front/user/login.html.twig', array(
  520.                 'message' => 'Votre lien a expiré. Merci de réassayer.',
  521.             ));
  522.         }
  523.         // Activation du compte et redirection vers la page login
  524.         $user = $this->em->getRepository(User::class)->findOneBy(array('email' => $email));
  525.         // Vérification existance utiliateur
  526.         if (!$user) {
  527.             return $this->render('front/user/login.html.twig', array(
  528.                 'message' => "Votre email n'existe pas.",
  529.             ));
  530.         }
  532.         return $this->render('front/user/password.html.twig', array(
  533.             'message' => "Saisir votre nouvelle mot de passe.",
  534.             'key' => $key
  535.         ));
  536.     }
  538.     /**
  539.      * @Route("/api/user_signup", name="api_user_signup", options={"expose"=true}, methods={"POST"})
  540.      */
  541.     public function userSignUpAPI(Request $request, UserPasswordEncoderInterface $passwordEncoder, MessageBusInterface $bus): Response
  542.     {
  543.         $client = json_decode($request->request->get('client'), true);
  545.         // Vérifier les saisies obligatoires
  546.         if ($client['nom'] == '') {
  547.             $response = [
  548.                 'res' => 'ERROR',
  549.                 'message' => "Le nom est obligatoire",
  550.             ];
  551.         } elseif ($client['prenom'] == '') {
  552.             $response = [
  553.                 'res' => 'ERROR',
  554.                 'message' => "Le prénom est obligatoire",
  555.             ];
  556.         } /*elseif ($client['username'] == '') {
  557.             $response = [
  558.                 'res' => 'ERROR',
  559.                 'message' => "Le nom d'utilisateur est obligatoire",
  560.             ];
  561.         } */elseif ($client['telephone'] == '') {
  562.             $response = [
  563.                 'res' => 'ERROR',
  564.                 'message' => "Le numéro de téléphone est obligatoire",
  565.             ];
  566.         } elseif ($client['email'] == '') {
  567.             $response = [
  568.                 'res' => 'ERROR',
  569.                 'message' => "L'adresse mail est obligatoire",
  570.             ];
  571.         } elseif (!filter_var($client['email'], FILTER_VALIDATE_EMAIL)) {
  572.             $response = [
  573.                 'res' => 'ERROR',
  574.                 'message' => "L'adresse mail n'est pas valide",
  575.             ];
  576.         } elseif (strlen($client['password']) == 0) {
  577.             $response = [
  578.                 'res' => 'ERROR',
  579.                 'message' => "Le mot de passe est obligatoire",
  580.             ];
  581.         } elseif (strlen($client['password']) < 6 && strlen($client['password']) > 0) {
  582.             $response = [
  583.                 'res' => 'ERROR',
  584.                 'message' => "La longueur de mot de passe doît être supérieur à 5",
  585.             ];
  586.         } elseif (strlen($client['confirmPassword']) == 0) {
  587.             $response = [
  588.                 'res' => 'ERROR',
  589.                 'message' => "Saisir la confirmaion de mot de passe",
  590.             ];
  591.         } elseif (strlen($client['confirmPassword']) < 6 && strlen($client['confirmPassword']) > 0) {
  592.             $response = [
  593.                 'res' => 'ERROR',
  594.                 'message' => "La longueur de confirmation mot de passe doît être supérieur à 5",
  595.             ];
  596.         } elseif ($client['password'] != $client['confirmPassword']) {
  597.             $response = [
  598.                 'res' => 'ERROR',
  599.                 'message' => "La confirmation de mot de passe ne correspond pas",
  600.             ];
  601.         } elseif (!$client['accept']) {
  602.             $response = [
  603.                 'res' => 'ERROR',
  604.                 'message' => "Veuillez accepter les termes et la politique",
  605.             ];
  606.         } else {
  607.             // Vérification de l'existance de client
  608.             $userByPhone = $this->em->getRepository(User::class)->findOneBy(array('phone' => str_replace(' ', '', $client['telephone'])));
  609. //            $userByUsername = $this->em->getRepository(User::class)->findOneBy(array('usermane' => $client['username']));
  610.             $userByUsername = $this->em->getRepository(User::class)->findOneBy(array('usermane' => $client['email']));
  611.             $userByMail = $this->em->getRepository(User::class)->findOneBy(array('email' => $client['email']));
  612.             //$userAll = $this->em->getRepository(User::class)->findOneBy(array('email' => $client['email'], 'phone' => str_replace(' ', '', $client['telephone']), 'usermane' => $client['username'], 'isVerified' => 0));
  613.             $userAll = $this->em->getRepository(User::class)->findOneBy(array('email' => $client['email'], 'phone' => str_replace(' ', '', $client['telephone']), 'usermane' => $client['email'], 'isVerified' => 0));
  614.             if ($userAll) {
  615.                 $response = [
  616.                     'res' => 'ERROR',
  617.                     'message' => "Ce compte existe mais n'est pas vérifié.",
  618.                 ];
  619.             } elseif ($userByPhone) {
  620.                 $response = [
  621.                     'res' => 'ERROR',
  622.                     'message' => "Numéro de téléphone déja utilisé.",
  623.                 ];
  624.             } elseif ($userByUsername) {
  625.                 $response = [
  626.                     'res' => 'ERROR',
  627.                     //'message' => "Nom d'utilisateur déja utilisé.",
  628.                     'message' => "E-mail déja utilisé.",
  629.                 ];
  630.             } elseif ($userByMail) {
  631.                 $response = [
  632.                     'res' => 'ERROR',
  633.                     'message' => "E-mail déja utilisé.",
  634.                 ];
  635.             } else {
  636.                 // Suspend auto commit : début de la transaction
  637.                 $this->em->getConnection()->beginTransaction();
  638.                 try {
  639.                     // Création de nouveau utiliateur
  640.                     $user = new User();
  641.                     $user->setType('client');
  642. //                    $user->setUsermane($client['username']);
  643.                     $user->setUsermane($client['email']);
  644.                     $user->setFirstName($client['nom']);
  645.                     $user->setLastName($client['prenom']);
  646.                     //$user->setCity($client['civilite']);
  647.                     $user->setPhone(str_replace('', '', $client['telephone']));
  648.                     $user->setEmail($client['email']);
  649.                     $user->setCreatedAt(new \DateTime('now'));
  650.                     $user->setCivility($client['civilite']);
  651.                     // Mot de passe
  652.                     $user->setPassword(
  653.                         $passwordEncoder->encodePassword(
  654.                             $user,
  655.                             $client['password']
  656.                         )
  657.                     );
  658.                     // Enregistrer le nouveau client
  659.                     $this->em->persist($user);
  660.                     $this->em->flush();
  662.                     // Génération de chaine de username crypté
  663.                     $key = $this->encrypt($user->getUsermane());
  665.                     // Envoi de mail
  666.                     if (isset($_ENV['MAILER_DSN']) && isset($_ENV['MAILER_MAIL'])) {
  667.                         if ($user->getEmail() && filter_var($user->getEmail(), FILTER_VALIDATE_EMAIL)) {
  668.                             $bus->dispatch(new Mail('front/mail/activation.html.twig', null, $key, $user->getEmail(), 'Activation compte SUNSHINE-ELEGANCE'), [new DelayStamp(10000)]);
  669.                         }
  670.                     };
  671.                     // Try and commit the transaction
  672.                     $this->em->getConnection()->commit();
  673.                 } catch (Exception $e) {
  674.                     // Rollback the failed transaction
  675.                     $this->em->getConnection()->rollBack();
  676.                     throw $e;
  677.                 }
  678.                 $response = [
  679.                     'res' => 'OK',
  680.                     'message' => 'Votre compte a été crée avec succès. Consulter votre boite mail pour activer votre compte.',
  681.                 ];
  682.             }
  684.         }
  686.         return new jsonResponse($response);
  687.     }
  689.     /**
  690.      * @Route("/user-request-password", name="user_request_password", methods={"GET"})
  691.      */
  692.     public function requestPassword(Request $request): Response
  693.     {
  694.         return $this->render('front/user/requestPassword.html.twig');
  695.     }
  697.     /**
  698.      * @Route("/user-request-verify", name="user_request_verify", methods={"GET"})
  699.      */
  700.     public function requestVerify(Request $request): Response
  701.     {
  702.         return $this->render('front/user/requestVerify.html.twig');
  703.     }
  704.     /**
  705.      * @Route("/api/user-change-password", name="api_user_change_password", options={"expose"=true}, methods={"POST"})
  706.      */
  707.     public function changePasswordAPI(Request $request, UserPasswordEncoderInterface $passwordEncoder, MessageBusInterface $bus): Response
  708.     {
  709.         $client = json_decode($request->request->get('client'), true);
  711.         // Vérifier les saisies obligatoires
  712.         if (strlen($client['password']) == 0) {
  713.             $response = [
  714.                 'res' => 'ERROR',
  715.                 'message' => "Saisir votre nouveau passe",
  716.             ];
  717.         } elseif (strlen($client['password']) < 6 && strlen($client['password']) > 0) {
  718.             $response = [
  719.                 'res' => 'ERROR',
  720.                 'message' => "La longueur de mot de passe doît être supérieur à 5",
  721.             ];
  722.         } elseif (strlen($client['confMotDePasse']) == 0) {
  723.             $response = [
  724.                 'res' => 'ERROR',
  725.                 'message' => "Saisir la confirmaion de mot de passe",
  726.             ];
  727.         } elseif (strlen($client['confMotDePasse']) < 6 && strlen($client['confMotDePasse']) > 0) {
  728.             $response = [
  729.                 'res' => 'ERROR',
  730.                 'message' => "La longueur de confirmation mot de passe doît être supérieur à 5",
  731.             ];
  732.         } elseif ($client['password'] != $client['confMotDePasse']) {
  733.             $response = [
  734.                 'res' => 'ERROR',
  735.                 'message' => "La confirmation de mot de passe ne correspond pas",
  736.             ];
  737.         } else {
  738.             $string = $this->decrypt($client['key']);
  740.             $parts = explode('|', $string);
  741.             // Récupérer le nom utilisateur
  742.             $email = $parts[0];
  743.             // Récupérer la date d'inscription
  744.             $dateRestore = $parts[1];
  746.             $date = strtotime('now');
  747.             $dateRestore = strtotime($dateRestore);
  749.             // Vérifier si le lien a expiré (envoyé depuis plus de 30 minutes)
  750.             if (round(abs($date - $dateRestore) / 60, 2) > 30) {
  751.                 return $this->render('front/user/login.html.twig', array(
  752.                     'message' => 'Votre lien a expiré. Merci de réassayer.',
  753.                 ));
  754.             }
  755.             // Activation du compte et redirection vers la page login
  756.             $user = $this->em->getRepository(User::class)->findOneBy(array('email' => $email));
  757.             // Vérification existance utiliateur
  758.             if (!$user) {
  759.                 return $this->render('front/user/login.html.twig', array(
  760.                     'message' => "Votre nom d'utilisateur n'existe pas.",
  761.                 ));
  762.             }
  764.             // Mot de passe
  765.             $user->setPassword(
  766.                 $passwordEncoder->encodePassword(
  767.                     $user,
  768.                     $client['password']
  769.                 )
  770.             );
  772.             // Enregistrement
  773.             $this->em->persist($user);
  774.             $this->em->flush();
  776.             /*return $this->render('front/user/login.html.twig', array(
  777.                 'message' => "Votre compte a été vérifié. Merci de connecter.",
  778.             ));*/
  780.             $response = [
  781.                 'res' => 'OK',
  782.                 'message' => 'Votre mote de passe a été réinitialisé avec succès.',
  783.             ];
  784.         }
  785.         return new jsonResponse($response);
  786.     }
  788.     /**
  789.      * @Route("/email-test", name="email_test", options={"expose"=true}, methods={"GET"})
  790.      */
  791.     public function emailTest(Request $request, MessageBusInterface $bus): Response
  792.     {
  793.         $document = $this->em->getRepository(Document::class)->find(26119);
  794.         // send mail
  795.         $bus->dispatch(new Mail('front/mail/order.html.twig', $document), [new DelayStamp(10000)]);
  797.         $response = [
  798.             'res' => 'Ok',
  799.             'message' => 'Email envoyé.',
  800.         ];
  801.         return new jsonResponse($response);
  802.     }
  804.     /**
  805.      * @Route("/api/user-request-password", name="api_user_request_password", options={"expose"=true}, methods={"POST"})
  806.      */
  807.     public function requestPasswordAPI(Request $request, UserPasswordEncoderInterface $passwordEncoder, MessageBusInterface $bus): Response
  808.     {
  809.         $client = json_decode($request->request->get('client'), true);
  811.         // Vérifier les saisies obligatoires
  812.         if ($client['email'] == '') {
  813.             $response = [
  814.                 'res' => 'ERROR',
  815.                 'message' => "L'adresse mail est obligatoire",
  816.             ];
  817.         } elseif (!filter_var($client['email'], FILTER_VALIDATE_EMAIL)) {
  818.             $response = [
  819.                 'res' => 'ERROR',
  820.                 'message' => "L'adresse mail n'est pas valide",
  821.             ];
  822.         } else {
  823.             // Vérification de l'existance de client
  824.             // $userByUsername = $this->em->getRepository(User::class)->findOneBy(array('usermane' => $client['email']));
  825.             $userByMail = $this->em->getRepository(User::class)->findOneBy(array('email' => $client['email']));
  826.             /*if (!$userByUsername) {
  827.                 $response = [
  828.                     'res' => 'ERROR',
  829.                     'message' => "Nom d'utilisateur inexistant.",
  830.                 ];
  831.             } */
  832.             if (!$userByMail) {
  833.                 $response = [
  834.                     'res' => 'ERROR',
  835.                     'message' => "E-mail inexistant.",
  836.                 ];
  837.             } else {
  838.                 // Suspend auto commit : début de la transaction
  839.                 $this->em->getConnection()->beginTransaction();
  840.                 try {
  841.                     // Génération de chaine de username crypté
  842.                     $key = $this->encrypt($userByMail->getEmail());
  843.                     // Envoi de mail
  844.                     if (isset($_ENV['MAILER_DSN']) && isset($_ENV['MAILER_MAIL'])) {
  845.                         if ($client['email'] && filter_var($client['email'], FILTER_VALIDATE_EMAIL)) {
  846.                             $bus->dispatch(new Mail('front/mail/password.html.twig', null, $key, $userByMail->getEmail(), 'Réinitialisation mot de passe'), [new DelayStamp(10000)]);
  847.                         }
  848.                     };
  849.                     // Try and commit the transaction
  850.                     $this->em->getConnection()->commit();
  851.                 } catch (Exception $e) {
  852.                     // Rollback the failed transaction
  853.                     $this->em->getConnection()->rollBack();
  854.                     throw $e;
  855.                 }
  856.                 $response = [
  857.                     'res' => 'OK',
  858.                     'message' => 'Un e-mail de réinitialisation de mot de passe vous a été envoyé. Merci de consulter votre boite mail.',
  859.                 ];
  860.             }
  861.         }
  862.         return new jsonResponse($response);
  863.     }
  865.     /**
  866.      * @Route("/api/user_request_verify", name="api_user_request_verify", options={"expose"=true}, methods={"POST"})
  867.      */
  868.     public function requestUserVerifyAPI(Request $request, UserPasswordEncoderInterface $passwordEncoder, MessageBusInterface $bus): Response
  869.     {
  870.         $client = json_decode($request->request->get('client'), true);
  872.         // Vérifier les saisies obligatoires
  873.         if ($client['email'] == '') {
  874.             $response = [
  875.                 'res' => 'ERROR',
  876.                 'message' => "L'adresse mail est obligatoire",
  877.             ];
  878.         } elseif (!filter_var($client['email'], FILTER_VALIDATE_EMAIL)) {
  879.             $response = [
  880.                 'res' => 'ERROR',
  881.                 'message' => "L'adresse mail n'est pas valide",
  882.             ];
  883.         } else {
  884.             // Vérification de l'existance de client
  885.             // $userByUsername = $this->em->getRepository(User::class)->findOneBy(array('usermane' => $client['email']));
  886.             $userByMail = $this->em->getRepository(User::class)->findOneBy(array('email' => $client['email']));
  887.             /*if (!$userByUsername) {
  888.                 $response = [
  889.                     'res' => 'ERROR',
  890.                     'message' => "Nom d'utilisateur inexistant.",
  891.                 ];
  892.             } */
  893.             if (!$userByMail) {
  894.                 $response = [
  895.                     'res' => 'ERROR',
  896.                     'message' => "E-mail inexistant.",
  897.                 ];
  898.             } else {
  899.                 // Suspend auto commit : début de la transaction
  900.                 $this->em->getConnection()->beginTransaction();
  901.                 try {
  902.                     // Génération de chaine de username crypté
  903.                     $key = $this->encrypt($userByMail->getUsermane());
  904.                     // Envoi de mail
  905.                     if (isset($_ENV['MAILER_DSN']) && isset($_ENV['MAILER_MAIL'])) {
  906.                         if ($client['email'] && filter_var($client['email'], FILTER_VALIDATE_EMAIL)) {
  907.                             $bus->dispatch(new Mail('front/mail/activation.html.twig', null, $key, $userByMail->getEmail(), 'Activation compte SUNSHINE-ELEGANCE'), [new DelayStamp(10000)]);
  908.                         }
  909.                     };
  910.                     // Try and commit the transaction
  911.                     $this->em->getConnection()->commit();
  912.                 } catch (Exception $e) {
  913.                     // Rollback the failed transaction
  914.                     $this->em->getConnection()->rollBack();
  915.                     throw $e;
  916.                 }
  917.                 $response = [
  918.                     'res' => 'OK',
  919.                     'message' => 'Un e-mail de vérification vous a été envoyé. Merci de consulter votre boite mail.',
  920.                 ];
  921.             }
  922.         }
  923.         return new jsonResponse($response);
  924.     }
  926.     /**
  927.      * @Route("/api/user_contact", name="api_user_contact", options={"expose"=true}, methods={"POST"})
  928.      */
  929.     public function userContactAPI(Request $request, UserPasswordEncoderInterface $passwordEncoder, MessageBusInterface $bus): Response
  930.     {
  931.         $client = json_decode($request->request->get('client'), true);
  933.         // Vérifier les saisies obligatoires
  934.         if ($client['telephone'] == '') {
  935.             $response = [
  936.                 'res' => 'ERROR',
  937.                 'message' => "Le numéro de téléphone est obligatoire.",
  938.             ];
  939.         } elseif ($client['email'] != '' && !filter_var($client['email'], FILTER_VALIDATE_EMAIL)) {
  940.             $response = [
  941.                 'res' => 'ERROR',
  942.                 'message' => "L'adresse mail n'est pas valide.",
  943.             ];
  945.         } elseif ($client['message'] == '') {
  946.             $response = [
  947.                 'res' => 'ERROR',
  948.                 'message' => "Saisir votre message.",
  949.             ];
  950.         } else {
  951.             // Envoi de mail
  952.             if (isset($_ENV['MAILER_DSN']) && isset($_ENV['MAILER_MAIL']) && isset($_ENV['MAILER_CONTACT'])) {
  953.                 if (filter_var($_ENV['MAILER_CONTACT'], FILTER_VALIDATE_EMAIL)) {
  954.                     $bus->dispatch(new Mail('front/mail/contact.html.twig', null, null, $_ENV['MAILER_CONTACT'], 'Message client contact', $client), [new DelayStamp(10000)]);
  955.                 }
  956.             };
  957.             $response = [
  958.                 'res' => 'OK',
  959.                 'message' => 'Votre message a été envoyé avec succès.'
  960.             ];
  961.         }
  962.         return new jsonResponse($response);
  963.     }
  965. }