src/Controller/Front/FrontCustomerAccountController.php line 601

Open in your IDE?
  1. <?php
  3. namespace Acme\SudcmsBundle\Controller\Front;
  5. use Acme\SudcmsBundle\Entity\AuthUser;
  6. use Acme\SudcmsBundle\Entity\EcoCustomers;
  7. use Acme\SudcmsBundle\Entity\EcoCustomersAddresses;
  8. use Acme\SudcmsBundle\Entity\Newsletter;
  9. use Acme\SudcmsBundle\Entity\Tchat;
  10. use Acme\SudcmsBundle\Entity\TchatMessages;
  11. use Acme\SudcmsBundle\Entity\TchatProducts;
  12. use Acme\SudcmsBundle\Form\Ecommerce\CustomerFrontType;
  13. use Acme\SudcmsBundle\Form\Ecommerce\CustomerResetPasswordType;
  14. use Acme\SudcmsBundle\Repository\AuthUserRepository;
  15. use Acme\SudcmsBundle\Repository\EcoCustomersAddressesRepository;
  16. use Acme\SudcmsBundle\Repository\EcoCustomersRepository;
  17. use Acme\SudcmsBundle\Repository\EcoInvoicesRepository;
  18. use Acme\SudcmsBundle\Repository\EcoOrdersRepository;
  19. use Acme\SudcmsBundle\Repository\EcoPlanningRepository;
  20. use Acme\SudcmsBundle\Repository\EcoProductsReferencesRepository;
  21. use Acme\SudcmsBundle\Repository\EcoShippingfeesCountryRepository;
  22. use Acme\SudcmsBundle\Repository\EcoShippingOrdersRepository;
  23. use Acme\SudcmsBundle\Repository\SiteRepository;
  24. use Acme\SudcmsBundle\Repository\TchatMessagesRepository;
  25. use Acme\SudcmsBundle\Repository\TchatProductsRepository;
  26. use Acme\SudcmsBundle\Repository\TchatRepository;
  27. use Acme\SudcmsBundle\Service\ApiService;
  28. use Acme\SudcmsBundle\Service\Ecommerce\LoyaltySystemService;
  29. use Acme\SudcmsBundle\Service\FileService;
  30. use Acme\SudcmsBundle\Service\MailerService;
  31. use Acme\SudcmsBundle\Service\OtideaUtils;
  32. use Doctrine\ORM\EntityManagerInterface;
  33. use Exception;
  34. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  35. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  36. use Symfony\Component\HttpFoundation\JsonResponse;
  37. use Symfony\Component\HttpFoundation\Request;
  38. use Symfony\Component\HttpFoundation\RequestStack;
  39. use Symfony\Component\HttpFoundation\Response;
  40. use Symfony\Component\HttpKernel\KernelInterface;
  41. use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
  42. use Symfony\Component\Routing\Annotation\Route;
  43. use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
  44. use Throwable;
  45. use const SITE_NAME;
  47. class FrontCustomerAccountController extends AbstractController
  48. {
  50.     private $session;
  51.     private $otideaUtils;
  52.     private $mailerService;
  53.     private $autorizedFiles = ['jpg', 'jpeg', 'png', 'pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx'];
  54.     private $fileService;
  55.     private $isEcommerce;
  56.     private $currentUserConnected;
  58.     private ApiService $apiService;
  60.     public function __construct(RequestStack   $requestStack, EntityManagerInterface $entityManager,
  61.                                 OtideaUtils    $otideaUtils, MailerService $mailerService, FileService $fileService,
  62.                                 SiteRepository $siteRepository, ApiService $apiService)
  63.     {
  64.         $this->session = $requestStack->getCurrentRequest()->getSession();
  66.         $this->apiService = $apiService;
  67.         $this->entityManager = $entityManager;
  68.         $this->otideaUtils = $otideaUtils;
  69.         $this->mailerService = $mailerService;
  70.         $this->fileService = $fileService;
  71.         $this->isEcommerce = $siteRepository->find($this->session->get('admin_site_uid'))->getIsEcommerce();
  72.         $this->currentUserConnected = $otideaUtils->getUserConnected();
  74.         if (!IS_ECOMMERCE) {
  75.             header('Location: ' . WEBSITEROOT);
  76.             exit;
  77.         }
  79.         if (!$this->apiService->testConnexion()) {
  80.             $this->addFlash('danger', 'Une erreur est survenue, veuillez réessayer ultérieurement.');
  81.             return $this->redirectToRoute('front_home');
  82.         }
  83.     }
  85.     /**
  86.      * Envoi un mail avec un nouveau mot de passe
  87.      * @param int $authUser_id
  88.      */
  89.     private function sendNotificationNewPassword($authUser_id)
  90.     {
  91.         $this->mailerService->fromName = SITE_NAME;
  92.         $this->mailerService->subject = SITE_NAME . " - Mot de passe oublié";
  94.         $authUser = $this->entityManager->getRepository(AuthUser::class)->find($authUser_id);
  96.         //Enregistrement du nouveau mot de passe
  97.         $newPassword = uniqid();
  98.         $password_hash = password_hash($newPassword, PASSWORD_DEFAULT);
  99.         $authUser->setPassword($password_hash);
  100.         $this->entityManager->persist($authUser);
  101.         $this->entityManager->flush();
  103.         $customer = $this->entityManager->getRepository(EcoCustomers::class)->findOneBy(['authUserId' => $authUser_id]);
  105.         $allRecipients[] = [
  106.             "nom" => $customer->getCustLastname(),
  107.             "prenom" => $customer->getCustFirstname(),
  108.             "email" => $customer->getAuthUserId()->getEmail(),
  109.             "type" => 'to'
  110.         ];
  112.         $htmlContent = $this->renderView('layouts/layouts_emails/notification_new_password.html.twig', [
  113.             'password' => $newPassword,
  114.         ]);
  116.         $this->mailerService->sendMail($allRecipients, $htmlContent);
  117.     }
  119.     #[Route(path: '/inscription', name: 'front_customer_registration')]
  120.     public function inscription(Request                     $request,
  121.                                 AuthUserRepository          $repoAuthUser,
  122.                                 EcoCustomersRepository      $ecoCustomersRepository,
  123.                                 UserPasswordHasherInterface $passwordHasher,
  124.                                 ApiService                  $api): Response
  125.     {
  127.         //Verification Recaptcha
  128.         $recaptcha_url = 'https://www.google.com/recaptcha/api/siteverify';
  129.         $recaptcha_secret = '6LfFKr0qAAAAAO8QfV8HQcPKViozt2RGLY7A2ORL';
  130.         $recaptcha_response = $_POST['g-recaptcha-response'];
  132.         // Make and decode POST request:
  133.         $recaptcha = file_get_contents($recaptcha_url . '?secret=' . $recaptcha_secret . '&response=' . $recaptcha_response);
  134.         $recaptcha = json_decode($recaptcha);
  136.         if ($recaptcha->score >= 0.5) {
  138.             // Récupération du formulaire d'inscription
  139.             $newCustomer = $request->request->get('customer_front');
  141.             // Vérification si l'utilisateur existe déjà en BDD
  142.             if ($repoAuthUser->findOneBy(['email' => $newCustomer['AdrCourriel']])) {
  143.                 $this->addFlash('danger', 'Cet utilisateur existe déjà');
  144.                 return $this->redirectToRoute('front_app_login');
  145.             }
  147.             // Création du ECO_CUSTOMER et du AUTH_USER en BDD
  148.             $addCustomer = new EcoCustomers();
  149.             $addAuthUser = new AuthUser();
  151.             $addCustomer->setCustCreationDate(new \DateTime());
  152.             $addCustomer->setAuthUserId($addAuthUser);
  153.             $addCustomer->setOdysseeReference(0);
  155.             $addAuthUser->setCreationDatetime(new \DateTime());
  156.             $addAuthUser->setRoles(["ROLE_USER", "ROLE_CUSTOMER"]);
  157.             $addAuthUser->setEmail($newCustomer['AdrCourriel']);
  159.             if ($newCustomer['password']['first'] != null) {
  160.                 $hashedPassword = $passwordHasher->hashPassword(
  161.                     $addAuthUser,
  162.                     $newCustomer['password']['first']
  163.                 );
  164.                 $addAuthUser->setPassword($hashedPassword);
  165.             } else {
  166.                 $this->addFlash('danger', 'Un mot de passe conforme est requis');
  167.                 return $this->redirectToRoute('front_app_login');
  168.             }
  170.             if (!filter_var($newCustomer['AdrCourriel'], FILTER_VALIDATE_EMAIL) && strlen($newCustomer['AdrCourriel']) < 6) {
  171.                 $this->addFlash('danger', 'Veuillez entrer une adresse email valide.');
  172.                 return $this->redirectToRoute('front_app_login');
  173.             }
  176.             $this->entityManager->persist($addCustomer);
  177.             $this->entityManager->persist($addAuthUser);
  178.             $this->entityManager->flush();
  180.             $result = $this->editCustomer($newCustomer, $addCustomer, $addAuthUser, $api);
  182.             if ($result == 'ok') {
  183.                 $this->addFlash('success', 'Votre compte a bien été créé');
  184.                 $this->authenticateUser($addAuthUser);
  185.                 if ($request->getSession()->get('_security.main.target_path')) {
  186.                     return $this->redirect($request->getSession()->get('_security.main.target_path'));
  187.                 }
  188.             } else {
  189.                 $this->addFlash('danger', $result);
  190.             }
  191.         } else {
  192.             $this->addFlash('danger', 'Vous êtes un robots');
  193.             return $this->redirectToRoute('front_app_login');
  194.         }
  196.         return $this->redirectToRoute('front_app_login');
  197.     }
  199.     //Fonction de connexion automatique après inscription
  200.     private function authenticateUser(AuthUser $user)
  201.     {
  202.         $providerKey = 'main'; // your firewall name
  203.         $token = new UsernamePasswordToken($user, null, $providerKey, $user->getRoles());
  205.         $this->container->get('security.token_storage')->setToken($token);
  206.     }
  208.     //Fonction d'édition des utilisateurs
  209.     private function editCustomer($newCustomer, $addCustomer, $addAuthUser, $api): string
  210.     {
  212.         if (is_object($newCustomer)) {
  213.             $newCustomer = (array)$newCustomer;
  214.         }
  216.         // On définie les valeurs par défaut si elles ne sont pas définies
  217.         $newCustomer['IdOdysseeClient'] = $newCustomer['IdOdysseeClient'] ?? 0;
  218.         $newCustomer['IdExterneClient'] = $newCustomer['IdExterneClient'] ?? 0;
  220.         // On recherche dans ODYSSEE si un client existe déjà avec cet email
  221.         $searchCustomer = $api->rechercherClient(idOdyssee: $newCustomer['IdOdysseeClient'],
  222.             adrCourriel: $newCustomer['AdrCourriel']);
  224.         // On transforme la date d'anniversaire
  225.         $birthday = new \DateTime($newCustomer->{'DateNaissance'} ?? $newCustomer['DateNaissance']);
  227.         // On modifie l'ID ODYSSEE si l'utilisateur existe déjà
  228.         $idOdyssee = (!isset($searchCustomer->{'status'}) && !empty($searchCustomer)) ? $searchCustomer[0]->{'IdOdysseeClient'} : $newCustomer['IdOdysseeClient'];
  230.         $addInOdyssee = null;
  232.         if (!isset($searchCustomer->{'status'}) && !empty($searchCustomer)) {
  233.             foreach ($searchCustomer as $customer) {
  234.                 if ($newCustomer['Nom'] == $customer->{'Nom'} && $newCustomer['Prenom'] == $customer->{'Prenom'}) {
  235.                     $addInOdyssee = $api->editFicheOdyssee(
  236.                         $idOdyssee,
  237.                         "" . $addCustomer->getId(),
  238.                         $newCustomer['Civilite'],
  239.                         $newCustomer['Nom'],
  240.                         $newCustomer['Prenom'],
  241.                         $birthday->format('Y-m-d\T00:00:00'),
  242.                         $newCustomer['Sexe'],
  243.                         $newCustomer['Adresse1'],
  244.                         $newCustomer['Adresse2'],
  245.                         $newCustomer['Adresse3'],
  246.                         $newCustomer['CodePostal'],
  247.                         $newCustomer['Ville'],
  248.                         $newCustomer['Pays'],
  249.                         $newCustomer['TelFixe'],
  250.                         $newCustomer['TelMobile'],
  251.                         $newCustomer['AdrCourriel'],
  252.                         isset($newCustomer['RefusComCom']) ? (int)$newCustomer['RefusComCom'] : 0,
  253.                         "update"
  254.                     );
  255.                     break;
  256.                 }
  257.             }
  258.         } else {
  259.             $addInOdyssee = $api->editFicheOdyssee(
  260.                 $idOdyssee,
  261.                 "" . $addCustomer->getId(),
  262.                 $newCustomer['Civilite'],
  263.                 $newCustomer['Nom'],
  264.                 $newCustomer['Prenom'],
  265.                 $birthday->format('Y-m-d\T00:00:00'),
  266.                 $newCustomer['Sexe'],
  267.                 $newCustomer['Adresse1'],
  268.                 $newCustomer['Adresse2'],
  269.                 $newCustomer['Adresse3'],
  270.                 $newCustomer['CodePostal'],
  271.                 $newCustomer['Ville'],
  272.                 $newCustomer['Pays'],
  273.                 $newCustomer['TelFixe'],
  274.                 $newCustomer['TelMobile'],
  275.                 $newCustomer['AdrCourriel'],
  276.                 isset($newCustomer['RefusComCom']) ? (int)$newCustomer['RefusComCom'] : 0
  277.             );
  278.         }
  280.         // On met a jour en BDD
  281.         $addCustomer->setOdysseeReference((!isset($searchCustomer->{'status'}) && !empty($searchCustomer) && $searchCustomer != 0) ? $searchCustomer[0]->{'IdOdysseeClient'} : (int)$addInOdyssee[0]->{'IdOdysseeClient'});
  282.         $this->entityManager->persist($addCustomer);
  283.         $this->entityManager->flush();
  285.         // Si on trouve plusieurs compte associés à l'email, on les créer
  286.         if (!isset($searchCustomer->{'status'}) && !empty($searchCustomer)) {
  287.             foreach ($searchCustomer as $cust) {
  289.                 if (!$this->entityManager->getRepository(EcoCustomers::class)->findOneBy(['odyssee_reference' => $cust->{'IdOdysseeClient'}])) {
  290.                     $addOtherCustomer = new EcoCustomers();
  291.                     $addOtherCustomer->setAuthUserId($addAuthUser);
  292.                     $addOtherCustomer->setOdysseeReference($cust->{'IdOdysseeClient'});
  293.                     $addOtherCustomer->setCustCreationDate(new \DateTime());
  294.                     $this->entityManager->persist($addOtherCustomer);
  295.                     $this->entityManager->flush();
  296.                 }
  297.             }
  298.         }
  300.         return 'ok';
  301.     }
  303.     /*
  304.      * Permet la création et la modification d'un compte client
  305.      * ainsi que la création de l'utilisateur
  306.      * @param $params array
  307.      * @return null
  308.      */
  309.     private function setCustomerAccount($params = [])
  310.     {
  311.         $form = isset($params['form']) ? $params['form'] : null;
  312.         $customer = isset($params['customer']) ? $params['customer'] : null;
  313.         $repoAuthUser = isset($params['repoAuthUser']) ? $params['repoAuthUser'] : null;
  314.         $repoNews = isset($params['repoNews']) ? $params['repoNews'] : null;
  315.         $passwordHasher = isset($params['passwordHasher']) ? $params['passwordHasher'] : null;
  316.         $repoEcoCustomerAddresses = isset($params['repoAddress']) ? $params['repoAddress'] : null;
  318.         if ($repoAuthUser !== null && $repoNews !== null && $passwordHasher !== null) {
  320.             // vérification de la validité de l'adresse email
  321.             if (!$this->validateEmails($form->get('email')->getData())) {
  322.                 $this->session->set('displayPopup', 'email-not-good');
  323.                 return $this->redirectToRoute('front_customer_registration');
  324.             }
  326.             // vérification que le compte client n'existe pas déjà
  327.             $emailSearch = $repoAuthUser->findOneBy(['email' => $form->get('email')->getData()]);
  328.             if ($emailSearch !== null && $customer->getId() == 0) {
  329.                 $this->session->set('displayPopup', 'email-exist');
  330.                 return $this->redirectToRoute('front_customer_registration');
  331.             }
  333.             $newCustomer = $customer->getAuthUserId() == null;
  334.             $user = $this->setUserAccount(!$newCustomer ? $customer->getAuthUserId()->getId() : null, $passwordHasher,
  335.                 $form, $repoAuthUser);
  337.             // @TODO connexion de l'utilisateur après sa création de compte
  338.             //                    $userAuthenticator->authenticateUser($user);
  340.             if ($customer->getId() == 0) {
  341.                 // liaison entre le compte utilisateur et le client
  342.                 $customer->setAuthUserId($user);
  343.                 $customer->setCustCreationDate(new \DateTime());
  344.                 // reference par defaut qui sera maj après l'enregistrement
  345.                 $customer->setCustReference("CLI");
  346.                 // pour la création d'un compte entreprise est confirmée par défaut
  347.                 $customer->setcustAccountStatus('confirmed');
  348.                 $customer->setCustAccountType('company');
  349.                 // FRANCE par défaut
  350.                 $customer->setCustCountryId(1);
  351.             }
  353.             // enregistrement du client
  354.             try {
  355.                 $this->entityManager->persist($customer);
  356.                 $this->entityManager->flush();
  357.             } catch (Exception $ex) {
  358.                 $this->addFlash('danger', "Une erreur s'est produite lors de l'enregistrement du compte");
  359.             }
  361.             // nouveau client,  definition du numéro client + maj
  362.             if ($newCustomer) {
  363.                 $ref = $customer->getId() + 1000;
  364.                 $customer->setCustReference("CLI" . $ref);
  366.                 try {
  367.                     $this->entityManager->persist($customer);
  368.                     $this->entityManager->flush();
  369.                 } catch (Exception $ex) {
  370.                     $this->addFlash('danger', "Une erreur s'est produite lors de la définition du numéro client");
  371.                 }
  372.             }
  374.             // enregistrement de l'adresse de livraison
  375.             if ($customer->getCustAccountType() == 'company') {
  376.                 $address = null;
  377.                 $addresses = $customer->getAddressesId();
  379.                 if (sizeof($addresses->getValues()) > 0) {
  380.                     foreach ($addresses as $add) {
  381.                         $address = $add;
  382.                         break;
  383.                     }
  384.                 }
  385.                 $this->setDeliveryAddress($customer, $form, $address);
  386.             }
  388.             // connexion auto du client après la creation du compte
  389.             //                $this->setCustomerConnection($customer->getId());
  391.             // inscription à la newsletter
  392.             $mailResult = $repoNews->findOneBy(['nlEmail' => $form->get('email')->getData()]);
  393.             if ($form->get('accept_newsletter')->getData() && $mailResult == NULL) {
  394.                 $this->subscriptionNewsletter($form->get('email')->getData());
  395.             }
  397.             // envoi du mail de confirmation de création de compte
  398.             if ($newCustomer) {
  399.                 $this->sendConfirmationNewAccount($form->get('email')->getData(), $form->getData());
  400.             }
  402.             $this->addFlash('success', "enregistré avec succès");
  404.             if ($this->session->has('returnToBasket')) {
  405.                 $this->session->remove('returnToBasket');
  406.                 return $this->redirectToRoute('front_basket_index');
  407.             }
  409.             return $this->redirectToRoute('front_customer_account');
  410.         }
  411.     }
  413.     /*
  414.      * Permet d'ajouter un nouveau compte client
  415.      * avec le role de client
  416.      * @return bool
  417.      */
  418.     private function setUserAccount($authUserId = 0, $passwordHasher = null, $form = null, $repoAuthUser = null)
  419.     {
  420.         if ($form->get('email')->getData() !== null) {
  422.             if ($authUserId > 0) {
  423.                 $user = $repoAuthUser->find($authUserId);
  424.             } else {
  425.                 $user = new AuthUser();
  426.             }
  428.             $user->setEmail($form->get('email')->getData());
  430.             // modification du mot de passe
  431.             if ($form->has('password') && $form->get('password')->getData() !== null && trim($form->get('password')->getData()) != "") {
  432.                 // hash the password (based on the security.yaml config for the $user class)
  433.                 $hashedPassword = $passwordHasher->hashPassword(
  434.                     $user,
  435.                     $form->get('password')->getData()
  436.                 );
  438.                 $user->setPassword($hashedPassword);
  439.             }
  441.             if ($user->getId() == 0) {
  442.                 $user->setRoles(array_merge($user->getRoles(), ['ROLE_CUSTOMER']));
  443.                 $user->setCreationDatetime(new \DateTime());
  444.             }
  446.             $this->entityManager->persist($user);
  447.             $this->entityManager->flush();
  449.             return $user;
  450.         }
  452.         return false;
  453.     }
  455.     /*
  456.      * Permet d'ajouter une adresse de livraison pour un client
  457.      * @param $customerId int identifiant du client dans eco_customer
  458.      * @param $form array les données du formulaire de compte
  459.      * @return void
  460.      */
  461.     private function setDeliveryAddress($customer = null, $form = null, $address = null)
  462.     {
  463.         if ($customer !== null && $form != null) {
  465.             if ($address !== null) {
  466.                 $deliveryAddress = $address;
  467.             } else {
  468.                 $deliveryAddress = new EcoCustomersAddresses();
  469.             }
  471.             $deliveryAddress->setCountryId(1); // PAR DEFAUT : FRANCE
  472.             $deliveryAddress->setCustomersId($customer);
  473.             $deliveryAddress->setAddressFirstname($form->get('cust_firstname')->getData());
  474.             $deliveryAddress->setAddressLastname($form->get('cust_lastname')->getData());
  475.             $deliveryAddress->setAddressCivility($form->get('cust_civility')->getData());
  477.             // address est null = nouveau compte
  478.             // address n'est pas null = compte existant maj des données
  479.             // nouveau compte : on verifie que le choix d'adresse identique entre facturation et livraison
  480.             if ($address !== null || ($form->has('same_billing_delivery') && !$form->get('same_billing_delivery')->getData())) {
  481.                 $deliveryAddress->setAddressPostal($form->get('address')->getData()->getAddressPostal());
  482.                 $deliveryAddress->setAddressAdditional($form->get('address')->getData()->getAddressAdditional());
  483.                 $deliveryAddress->setAddressDoor($form->get('address')->getData()->getAddressDoor());
  484.                 $deliveryAddress->setAddressBuilding($form->get('address')->getData()->getAddressBuilding());
  485.                 $deliveryAddress->setAddressFloor($form->get('address')->getData()->getAddressFloor());
  486.                 $deliveryAddress->setAddressPostalCode($form->get('address')->getData()->getAddressPostalCode());
  487.                 $deliveryAddress->setAddressCity($form->get('address')->getData()->getAddressCity());
  488.                 $deliveryAddress->setAddressSociety($form->get('address')->getData()->getAddressSociety());
  489.             } // adresse identique entre facturation et livraison
  490.             else {
  491.                 $deliveryAddress->setAddressPostal($form->get('cust_address')->getData());
  492.                 $deliveryAddress->setAddressAdditional($form->get('cust_additional_address')->getData());
  493.                 $deliveryAddress->setAddressDoor($form->get('cust_door')->getData());
  494.                 $deliveryAddress->setAddressBuilding($form->get('cust_building')->getData());
  495.                 $deliveryAddress->setAddressFloor($form->get('cust_floor')->getData());
  496.                 $deliveryAddress->setAddressPostalCode($form->get('cust_postal_code')->getData());
  497.                 $deliveryAddress->setAddressCity($form->get('cust_city')->getData());
  498.                 $deliveryAddress->setAddressSociety($form->get('cust_society')->getData());
  499.             }
  501.             try {
  502.                 $this->entityManager->persist($deliveryAddress);
  503.                 $this->entityManager->flush();
  504.             } catch (Exception $ex) {
  505.                 $this->addFlash('danger',
  506.                     "Une erreur s'est produite lors de l'enregistrement de l'adresse de livraison");
  507.             }
  508.         }
  509.     }
  511.     /*
  512.      * Permet d'envoyer le mail de confirmation
  513.      * de création de compte
  514.      * @param $email string l'email destinataire
  515.      * @param $formData array les données du form de création de compte
  516.      * @return void
  517.      */
  518.     private function sendConfirmationNewAccount($email = null, $formData = null)
  519.     {
  520.         if (isset($email) && isset($formData)) {
  521.             $this->mailerService->subject = "Demande d'adhésion sur " . SITE_NAME;
  523.             $htmlContent = $this->renderView('layouts/layouts_emails/notification_request_company.html.twig', [
  524.                 'formData' => $formData,
  525.                 'email' => $email,
  526.             ]);
  528.             $this->mailerService->sendMail([], $htmlContent, NULL, 'request-company');
  529.         }
  530.     }
  532.     /*
  533.      * Permet d'inscrire un nouveau mail à la newsletter
  534.      * @param $email string l'email à inscrire
  535.      * @return void
  536.      */
  537.     private function subscriptionNewsletter($email = "")
  538.     {
  539.         if ($email != "") {
  540.             $mail = new Newsletter();
  541.             $mail->setNlCreationDatetime(new \DateTime());
  542.             $mail->setNlEmail($email);
  543.             $mail->setNlRgpdChecked(true);
  545.             $this->entityManager->persist($mail);
  546.             $this->entityManager->flush();
  548.             try {
  549.                 $this->entityManager->persist($mail);
  550.                 $this->entityManager->flush();
  551.             } catch (Exception $ex) {
  552.                 $this->addFlash('danger',
  553.                     "Une erreur s'est produite lors de l'enregistrement de l'inscription à la newsletter");
  554.             }
  555.         }
  556.     }
  558.     /**
  559.      * Permet de redéfinir le mot de passe depuis le compte client
  560.      */
  561.     #[Route(path: '/compte-client/modifier-mot-de-passe', name: 'front_customer_edit_password')]
  562.     public function setUserPassword(Request            $request, UserPasswordHasherInterface $passwordHasher,
  563.                                     AuthUserRepository $repoAuthUser)
  564.     {
  565.         $form = $this->createForm(CustomerResetPasswordType::class);
  567.         $form->handleRequest($request);
  569.         if ($form->isSubmitted() && $form->isValid()) {
  571.             $user = $repoAuthUser->find($this->getUser()->getId());
  573.             // vérification du mot de passe actuel rentré avec celui dans la bdd
  574.             if (!$passwordHasher->isPasswordValid($user, $form->get('actualPassword')->getData())) {
  575.                 $this->addFlash('danger', 'Le mot de passe ne correspond pas à votre mot de passe actuel.');
  576.                 return $this->redirectToRoute('front_customer_account');
  577.             }
  579.             $hashedPassword = $passwordHasher->hashPassword(
  580.                 $user,
  581.                 $form->get('password')->getData()
  582.             );
  584.             $user->setPassword($hashedPassword);
  586.             $this->entityManager->persist($user);
  587.             $this->entityManager->flush();
  589.             $this->addFlash('success', 'Votre mot de passe a été changé. Veuillez vous reconnecter.');
  591.             return $this->redirectToRoute('front_app_logout');
  592.         }
  594.         return $this->redirectToRoute('front_customer_account');
  595.     }
  597.     /**
  598.      * @throws Throwable
  599.      */
  600.     #[Route(path: '/compte-client/mes-coordonnees/{refOdyssee}', name: 'front_customer_account')]
  601.     public function account(Request                     $request,
  602.                             EcoCustomersRepository      $ecoCustomersRepository,
  603.                             UserPasswordHasherInterface $passwordHasher,
  604.                             ApiService                  $api,
  605.                                                         $refOdyssee = null): Response
  606.     {
  608.         $previousRoute = $request->getSession()->get('previous_route');
  610.         if ($previousRoute === 'front_app_login') {
  611.             $request->getSession()->remove('previous_route');
  612.             return $this->redirectToRoute('front_shopping_categorie');
  613.         }
  615.         if ($this->currentUserConnected) {
  616.             $this->redirectToRoute('front_home');
  617.         }
  619.         $ecoCustomer = $refOdyssee ? $ecoCustomersRepository->findOneBy(['odyssee_reference' => $refOdyssee]) : $this->currentUserConnected;
  621.         $form = $this->createForm(CustomerFrontType::class, $ecoCustomer, [
  622.             'odysseeClient' => $api->rechParIdOdyssee($refOdyssee ?: $ecoCustomer->getOdysseeReference())[0],
  623.             'type' => $refOdyssee ? 'refOdyssee' : 'account'
  624.         ]);
  626.         $form->handleRequest($request);
  628.         if ($refOdyssee && !$ecoCustomersRepository->findOneBy(['odyssee_reference' => $refOdyssee])) {
  629.             $addCustomer = new EcoCustomers();
  630.             $addCustomer->setCustCreationDate(new \DateTime());
  631.             $addCustomer->setAuthUserId($this->currentUserConnected->getAuthUserId());
  632.             $addCustomer->setOdysseeReference(0);
  634.             $this->entityManager->persist($addCustomer);
  635.             $this->entityManager->flush();
  636.             $newCustomer = $form->getConfig()->getOptions()['odysseeClient'];
  638.             $this->editCustomer($newCustomer, $addCustomer, $this->currentUserConnected->getAuthUserId(), $api);
  640.             return $this->redirectToRoute('front_customer_account',
  641.                 ['refOdyssee' => $form->getConfig()->getOptions()['odysseeClient']->{'IdOdysseeClient'}]);
  643.         }
  645.         if ($form->isSubmitted() && $form->isValid()) {
  647.             try {
  649.                 $customer = $request->request->get('customer_front');
  650.                 if (!$refOdyssee) {
  651.                     $this->currentUserConnected->getAuthUserId()->setEmail($customer['AdrCourriel']);
  652.                     if ($customer['password']['first'] != null) {
  653.                         $hashedPassword = $passwordHasher->hashPassword(
  654.                             $this->currentUserConnected->getAuthUserId(),
  655.                             $customer['password']['first']
  656.                         );
  657.                         $this->currentUserConnected->getAuthUserId()->setPassword($hashedPassword);
  658.                     }
  661.                     $this->entityManager->persist($this->currentUserConnected->getAuthUserId());
  662.                     $this->entityManager->flush();
  664.                     foreach ($this->currentUserConnected->getAuthUserId()->getCustomer() as $cust) {
  666.                         $customerPush = $api->rechercherClient(idOdyssee: (int)$cust->getOdysseeReference());
  668.                         $this->editCustomer($customerPush[0], $cust,
  669.                             $this->currentUserConnected->getAuthUserId(),
  670.                             $api);
  671.                     }
  672.                 } else {
  674.                     $cust = $ecoCustomersRepository->findOneBy(['odyssee_reference' => $refOdyssee]);
  675.                     $customer['IdOdysseeClient'] = $refOdyssee;
  676.                     $customer['IdExterneClient'] = $cust->getId();
  677.                     $customer['AdrCourriel'] = $this->currentUserConnected->getAuthUserId()->getEmail();
  679.                     $this->editCustomer($customer, $cust,
  680.                         $this->currentUserConnected->getAuthUserId(),
  681.                         $api);
  683.                 }
  685.                 $this->addFlash('success', "enregistré avec succès");
  687.             } catch (Exception $ex) {
  688.                 $this->addFlash('danger', "Une erreur s'est produite lors de l'enregistrement ");
  689.             }
  691.             if ($request->query->get("from") !== null && $request->query->get("from") == "delivery") {
  692.                 return $this->redirectToRoute('front_basket_delivery');
  693.             } else {
  694.                 return $this->redirectToRoute('front_customer_account', ['refOdyssee' => $refOdyssee]);
  695.             }
  696.         }
  698.         $allOdysseeCustomers = [];
  699.         foreach ($this->currentUserConnected->getAuthUserId()->getCustomer() as $cust) {
  700.             $allOdysseeCustomers[] = $api->rechParIdOdyssee($cust->getOdysseeReference());
  701.         }
  703.         $allOdysseeCustomers = $api->rechercherClient(adrCourriel: $this->currentUserConnected->getAuthUserId()->getEmail());
  705.         $template = $refOdyssee ? 'ref_odyssee' : 'account';
  706.         $pageAccount = 'coordonnees';
  707.         $selectedMenu = $refOdyssee ?: 'email';
  709.         return $this->render('@main-app/front/front_customer_account/' . $template . '.html.twig', [
  710.             'form' => $form->createView(),
  711.             'pageAccount' => $pageAccount,
  712.             'selectedMenu' => $selectedMenu,
  713.             'customer' => $refOdyssee ? $ecoCustomersRepository->findOneBy(['odyssee_reference' => $refOdyssee]) : $this->currentUserConnected,
  714.             'user' => $this->currentUserConnected->getAuthUserId(),
  715.             'allOdysseeCustomers' => $allOdysseeCustomers
  716.         ]);
  717.     }
  719.     #[Route(path: '/compte-client/save-delivery', name: 'front_customer_save_delivery_address')]
  720.     public function saveDeliveryAddress(Request $request, EcoCustomersAddressesRepository $repoCustomersAddresses)
  721.     {
  722.         if ($request->isMethod('POST')) {
  724.             $deliveryAddress = $repoCustomersAddresses->find($request->get('delivery_id'));
  726.             if ($request->get('delivery_id') == 0) {
  727.                 $deliveryAddress = new EcoCustomersAddresses;
  728.                 $deliveryAddress->setCustomerId($this->currentUserConnected->getId());
  729.             }
  731.             //Enregistrement de l'adresse de livraison
  732.             $deliveryAddress->setCountryId($request->get('country_id'));
  733.             $deliveryAddress->setAddressCivility($request->get('address_civility'));
  734.             $deliveryAddress->setAddressFirstname($request->get('address_firstname'));
  735.             $deliveryAddress->setAddressLastname($request->get('address_lastname'));
  736.             $deliveryAddress->setAddressSociety($request->get('address_society'));
  737.             $deliveryAddress->setAddressPostalCode($request->get('address_postal_code'));
  738.             $deliveryAddress->setAddressCity($request->get('address_city'));
  739.             $deliveryAddress->setAddressPhone($request->get('address_phone'));
  740.             $deliveryAddress->setAddressEntitled($request->get('address_entitled'));
  742.             $this->entityManager->persist($deliveryAddress);
  743.             $this->entityManager->flush();
  745.             $this->addFlash('success', "enregistré avec succès");
  747.             if ($request->query->get("from") !== null && $request->query->get("from") == "delivery") {
  748.                 return $this->redirectToRoute('front_basket_delivery');
  749.             } else {
  750.                 return $this->redirectToRoute('front_customer_account');
  751.             }
  752.         }
  753.     }
  755.     /**
  756.      * @throws Throwable
  757.      */
  758.     #[Route(path: '/compte-client/mes-commandes', name: 'front_customer_orders')]
  759.     public function orders(Request                     $request,
  760.                            EcoOrdersRepository         $repoOrders,
  761.                            EcoShippingOrdersRepository $repoShippingOrders,
  762.                            LoyaltySystemService        $loyaltySystem,
  763.                            ApiService                  $api): Response
  764.     {
  766.         $customers = $this->currentUserConnected->getAuthUserId()->getCustomer();
  768.         $allAvailablesResaCures = [];
  770.         // On parcourt tous les clients attachés à ce compte
  771.         $orders = [];
  772.         foreach ($customers as $customer) {
  774.             // Récupération des commandes du client
  775.             $order = $api->rechercherResaCure(idOdysseeClient: (int)$customer->getOdysseeReference());
  777.             if (!isset($order->status)) {
  778.                 $orders[$customer->getOdysseeReference()] = $order;
  779.             }
  781.             // On parcours les cures, on ne garde que celles dont la date de début est supérieure à la date du jour
  782.             foreach ($orders as $patient) {
  783.                 foreach ($patient as $cure) {
  784.                     $dateDebut = new \DateTime($cure->{'Date_Debut_Resa'});
  785.                     $dateFin = new \DateTime($cure->{'Date_Fin_Resa'});
  786.                     $dateJour = new \DateTime();
  787.                     if ($dateDebut > $dateJour || $dateFin > $dateJour) {
  788.                         $allAvailablesResaCures[] = $cure;
  789.                     }
  790.                 }
  791.             }
  792.         }
  794.         $allOdysseeCustomers = $api->rechercherClient(adrCourriel: $this->currentUserConnected->getAuthUserId()->getEmail());
  796.         //TODO : si le site est un SPA, récupérer les résa et ventes SPA (non disponible dans l'API à ce jour)
  797.         if (ODYSSEE_TYPE == 'SPA') {
  798.             $allAvailablesResaCures = [];
  799.         }
  801.         return $this->render('@main-app/front/front_customer_account/orders.html.twig', [
  802.             'orders' => $allAvailablesResaCures,
  803.             'indicationsPrincipales' => $api->listerItp(),
  804.             'indicationsSecondaires' => $api->listerIts(),
  805.             'pageAccount' => 'commandes',
  806.             'allOdysseeCustomers' => $allOdysseeCustomers
  807.         ]);
  808.     }
  810.     /**
  811.      * @throws Throwable
  812.      */
  813.     #[Route(path: '/compte-client/ma-cure/{cure_id}', name: 'front_customer_order_cure')]
  814.     public function orderCure(Request                     $request, EcoOrdersRepository $repoOrders,
  815.                               EcoShippingOrdersRepository $repoShippingOrders,
  816.                               LoyaltySystemService        $loyaltySystem,
  817.                               ApiService                  $api, $cure_id = 0): Response
  818.     {
  820.         $customers = $this->currentUserConnected->getAuthUserId()->getCustomer();
  822.         if ($cure_id == 0) {
  823.             return $this->redirectToRoute('front_customer_orders');
  824.         }
  826.         // Récupération des commandes du client
  827.         $order = $api->rechercherResaCure(idOdysseeResa: (int)$cure_id);
  829.         if (!$order) {
  830.             return $this->redirectToRoute('front_customer_orders');
  831.         }
  833.         $medecinsPresc = [];
  834.         // Récupération du médecin prescripteur
  835.         if ($api->rechercherMedPrParCode($order[0]->{'Medecin_Prescripteur'})) {
  836.             $medecinsPresc = $api->rechercherMedPrParCode($order[0]->{'Medecin_Prescripteur'});
  837.         }
  839.         $curiste = $api->rechParIdOdyssee($order[0]->{'IdOdysseeClient'});
  841.         // Si il y a plusieurs curistes, on récupère le premier
  842.         if (is_array($curiste)) {
  843.             $curiste = $curiste[0];
  844.         }
  846.         return $this->render('@main-app/front/front_customer_account/order_cure.html.twig', [
  847.             'order' => $order[0],
  848.             'curiste' => $curiste,
  849.             'indicationsPrincipales' => $api->listerItp(),
  850.             'indicationsSecondaires' => $api->listerIts(),
  851.             'medecinsTherm' => $api->listerMedTh(),
  852.             'medecinsPresc' => $medecinsPresc,
  853.             'plagesHoraires' => $api->listerPlageHoraire(),
  854.             'etablissements' => $api->listerEtabResaCure(),
  855.             'pointsDeVente' => $api->listerPvResaCure(),
  856.             'pageAccount' => 'ma-cure'
  857.         ]);
  858.     }
  860.     #[Route(path: '/compte-client/ma-commande/{order_id}', name: 'front_customer_order_detail', defaults: ['order_id' => ''])]
  861.     public function order_detail(Request                         $request, EcoOrdersRepository $repoOrders,
  862.                                  EcoShippingOrdersRepository     $repoShippingOrders,
  863.                                  EcoProductsReferencesRepository $repoRef, $order_id,
  864.                                  EcoInvoicesRepository           $repoInvoices): Response
  865.     {
  866.         //Vérification que l'utilisateur est bien connecté
  867.         if (!$this->currentUserConnected || $this->currentUserConnected == null) {
  868.             return $this->redirectToRoute('front_customer_registration');
  869.         }
  871.         $order = $repoOrders->find($order_id);
  873.         //Vérification que la commande est bien la sienne 
  874.         if ($order == null || $order->getCustomerId() != $this->currentUserConnected->getId()) {
  875.             return $this->redirectToRoute('front_customer_orders');
  876.         }
  878.         return $this->render('@main-app/front/front_customer_account/order_detail.html.twig', [
  879.             'order' => $order,
  880.             'shipment' => $repoShippingOrders->findByShipmentOrders($this->currentUserConnected->getId()),
  881.             'references' => $repoRef->findByProductReferencesOrder($order_id, $isCanceled = 0),
  882.             'referencesCanceled' => $repoRef->findByProductReferencesOrder($order_id, $isCanceled = 1),
  883.             'invoices' => $repoInvoices->findByInvoices($this->currentUserConnected->getId(), 'invoice',
  884.                 $order_id),
  885.             'credit_note' => $repoInvoices->findByInvoices($this->currentUserConnected->getId(), 'credit_note',
  886.                 $order_id),
  887.             'pageAccount' => 'commande'
  888.         ]);
  889.     }
  891.     #[Route(path: '/compte-client/telecharger/{invoice_id}', name: 'front_customer_invoices_download', defaults: ['invoice_id' => 0])]
  892.     public function download(Request             $request, EcoInvoicesRepository $repoInvoices,
  893.                              EcoOrdersRepository $repoOrders, KernelInterface $appKernel, $invoice_id = 0)
  894.     {
  895.         if (!$this->currentUserConnected || $this->currentUserConnected == null) {
  896.             return $this->redirectToRoute('front_customer_registration');
  897.         }
  899.         //Vérification que la facture est bien la sienne 
  900.         $invoice = $repoInvoices->find($invoice_id);
  902.         if ($invoice !== null) {
  903.             $order = $repoOrders->find($invoice->getOrderId());
  904.             if ($order->getCustomerId() != $this->currentUserConnected->getId()) {
  905.                 return $this->redirectToRoute('front_customer_invoices');
  906.             }
  907.         } else {
  908.             return $this->redirectToRoute('front_customer_invoices');
  909.         }
  911.         //Téléchargement du fichier
  912.         $fileName = $invoice->getInvoiceFilename() != null ? $invoice->getInvoiceFilename() : 'walouuu.pdf';
  913.         $file = $appKernel->getProjectDir() . '/public/medias_front/orders/' . $fileName;
  915.         if (file_exists($file)) {
  916.             return new BinaryFileResponse($file);
  917.         } else {
  918.             return $this->redirectToRoute('front_customer_invoices');
  919.         }
  920.     }
  922.     #[Route(path: '/compte-client/mes-messages', name: 'front_customer_tchat')]
  923.     public function tchat(Request         $request, EcoCustomersRepository $repoCustomers,
  924.                           TchatRepository $repoTchat): Response
  925.     {
  926.         if (!$this->currentUserConnected || $this->currentUserConnected == null) {
  927.             return $this->redirectToRoute('front_customer_registration');
  928.         }
  930.         return $this->render('@main-app/front/front_customer_account/tchat.html.twig', [
  931.             'pageAccount' => 'messages',
  932.             'discussions' => $repoTchat->findByCustomerDiscussion($this->currentUserConnected->getId()),
  933.             'unreadMessages' => $repoTchat->controlIfDiscussionUnread($this->currentUserConnected->getId()),
  934.         ]);
  935.     }
  937.     #[Route(path: '/compte-client/nouveau-ticket', name: 'front_tchat_ticket')]
  938.     public function tchat_ticket(Request         $request, EcoCustomersRepository $repoCustomers,
  939.                                  TchatRepository $repoTchat, EcoOrdersRepository $repoOrders): Response
  940.     {
  941.         if (!$this->currentUserConnected || $this->currentUserConnected == null) {
  942.             return $this->redirectToRoute('front_customer_registration');
  943.         }
  945.         return $this->render('@main-app/front/front_customer_account/tchat_ticket.html.twig', [
  946.             'pageAccount' => 'messages',
  947.             'customer_id' => $this->currentUserConnected->getId(),
  948.             'orders' => $repoOrders->findBy(['order_status' => array('valid', 'partial-shipment', 'shipment'),
  949.                 'customer_id' => $this->currentUserConnected->getId()],
  950.                 ['order_date' => 'DESC'])
  951.         ]);
  952.     }
  954.     /**
  955.      * @param Request $request
  956.      */
  957.     #[Route(path: '/compte-client/axDisplayProductOrder', name: 'front_tchat_axDisplayProductOrder', options: ['expose' => true])]
  958.     public function axDisplayProductOrder(Request $request, EcoProductsReferencesRepository $repoProdRef)
  959.     {
  960.         if ($request->isXmlHttpRequest()) {
  962.             $renderList = $this->renderView('admin/admin_tchat/tpl_display_products.html.twig', [
  963.                 'references' => $repoProdRef->findByProductReferencesByOrder($request->get('order_id')),
  964.             ]);
  966.             $script = '';
  967.             $script .= " $('#products-list').html('" . str_replace(array("\n", "\r"), '',
  968.                     html_entity_decode(addslashes($renderList),
  969.                         ENT_QUOTES)) . "'); ";
  971.             return new JsonResponse([
  972.                 'status' => true,
  973.                 'script' => $script,
  974.             ]);
  975.         }
  977.         return new JsonResponse([
  978.             'status' => false,
  979.         ]);
  980.     }
  982.     #[Route(path: '/compte-client/open-ticket', name: 'front_tchat_open_conversation')]
  983.     public function openTicket(Request $request)
  984.     {
  985.         if ($request->get('customer_id') > 0) {
  987.             //Ouverture d'une conversation
  988.             $tchat = new Tchat();
  989.             $tchat->setUserId(0);
  990.             $tchat->setCustomerId($request->get('customer_id'));
  991.             $tchat->setTchatObject($request->get('tchat_object'));
  992.             $tchat->setTchatDatetime(new \DateTime());
  993.             $tchat->setTchatStatus('open');
  995.             $this->entityManager->persist($tchat);
  996.             $this->entityManager->flush();
  998.             //Ajout du message
  999.             $mess = new TchatMessages;
  1000.             $mess->setTchatId($tchat->getId());
  1001.             $mess->setUserId(0);
  1002.             $mess->setMessDatetime(new \DateTime());
  1003.             $mess->setMessage($request->get('message'));
  1004.             $mess->setMessRead(false);
  1006.             //Ajout d'une pièce jointe
  1007.             if ($request->files->get("mess_file")) {
  1008.                 $fileName = $this->fileService->startUpload([
  1009.                     "fileData" => $request->files->get("mess_file"),
  1010.                     "oldFileName" => NULL,
  1011.                     "fileDestination" => $this->getParameter("upload_tchat_" . CURRENT_SITE_ID),
  1012.                     "autorizedExtensions" => $this->autorizedFiles,
  1013.                     "createWebp" => false
  1014.                 ]);
  1016.                 $mess->setMessFile($fileName);
  1017.             }
  1019.             $this->entityManager->persist($mess);
  1020.             $this->entityManager->flush();
  1022.             //Liaison produits
  1023.             if ($request->get('references')) {
  1024.                 foreach ($request->get('references') as $op_id) {
  1025.                     $prodLink = new TchatProducts();
  1026.                     $prodLink->setTchatId($tchat->getId());
  1027.                     $prodLink->setOrderpId($op_id);
  1028.                     $this->entityManager->persist($prodLink);
  1029.                 }
  1030.                 $this->entityManager->flush();
  1031.             }
  1033.             $this->session->set('displayPopup', 'open-ticket');
  1034.             return $this->redirectToRoute('front_tchat_discussion', ['tchat_id' => $tchat->getId()]);
  1035.         }
  1037.         return $this->redirectToRoute('front_tchat_ticket');
  1038.     }
  1040.     #[Route(path: '/compte-client/discussion/{tchat_id}', name: 'front_tchat_discussion', defaults: ['tchat_id' => ''])]
  1041.     public function discussion(Request                 $request, TchatRepository $repoTchat,
  1042.                                TchatMessagesRepository $repoTchatMess, EcoCustomersRepository $repoCustomer,
  1043.                                AuthUserRepository      $repoUsers, TchatProductsRepository $repoTchatProds,
  1044.                                                        $tchat_id): Response
  1045.     {
  1046.         //Affichage popup
  1047.         $this->displayPopup();
  1049.         if ($tchat_id > 0) {
  1050.             $tchat = $repoTchat->find($tchat_id);
  1052.             //Access control
  1053.             if ($this->currentUserConnected == null || $this->currentUserConnected == false || $tchat->getCustomerId() != $this->currentUserConnected->getId()) {
  1054.                 return $this->redirectToRoute('front_customer_registration');
  1055.             }
  1057.         } else {
  1058.             return $this->redirectToRoute('front_customer_registration');
  1059.         }
  1061.         //Marquer les messages non lus
  1062.         $messages = $repoTchatMess->getAdminMessages();
  1064.         if (is_array($messages)) {
  1065.             foreach ($messages as $mess) {
  1066.                 if ($mess->getTchatId() == $tchat_id) {
  1067.                     $mess->setMessRead(true);
  1068.                     $this->entityManager->persist($mess);
  1069.                     $this->entityManager->flush();
  1070.                 }
  1071.             }
  1072.         }
  1074.         return $this->render('@main-app/front/front_customer_account/tchat_discussion.html.twig', [
  1075.             'pageAccount' => 'messages',
  1076.             'discussion' => $discussion = $repoTchat->find($tchat_id),
  1077.             'customer' => $repoCustomer->find($discussion->getCustomerId()),
  1078.             'messages' => $repoTchatMess->findBy(['tchat_id' => $tchat_id], ['mess_datetime' => 'DESC']),
  1079.             'users' => $repoUsers->findAll(),
  1080.             'products' => $repoTchatProds->findByTchatProducts($tchat_id),
  1081.             "autorizedExtensions" => $this->autorizedFiles,
  1082.         ]);
  1083.     }
  1085.     #[Route(path: '/compte-client/repondre', name: 'front_tchat_response')]
  1086.     public function response(Request $request): Response
  1087.     {
  1088.         if ($request->isMethod('POST')) {
  1090.             //Ajout du message
  1091.             $mess = new TchatMessages;
  1092.             $mess->setTchatId($request->get('tchat_id'));
  1093.             $mess->setUserId(0);
  1094.             $mess->setMessDatetime(new \DateTime());
  1095.             $mess->setMessage($request->get('message'));
  1096.             $mess->setMessFile(NULL);
  1097.             $mess->setMessRead(false);
  1099.             //Ajout d'une pièce jointe
  1100.             if ($request->files->get("mess_file")) {
  1101.                 $fileName = $this->fileService->startUpload(
  1102.                     [
  1103.                         "fileData" => $request->files->get("mess_file"),
  1104.                         "oldFileName" => NULL,
  1105.                         "fileDestination" => $this->getParameter("upload_tchat_" . CURRENT_SITE_ID),
  1106.                         "autorizedExtensions" => $this->autorizedFiles,
  1107.                         "createWebp" => false
  1108.                     ]
  1109.                 );
  1111.                 $mess->setMessFile($fileName);
  1112.             }
  1114.             $this->entityManager->persist($mess);
  1115.             $this->entityManager->flush();
  1117.             $this->session->set('displayPopup', 'send-message');
  1119.             //Envoyer un mail de notification à l'administrateur
  1120.             $this->newAdminMessageNotification($request->get('tchat_id'), $request->get('message'));
  1122.             return $this->redirectToRoute('front_tchat_discussion', ['tchat_id' => $request->get('tchat_id')]);
  1123.         }
  1125.         return $this->redirectToRoute('front_tchat');
  1126.     }
  1128.     /**
  1129.      * Notification à l'administrateur d'un nouveau message
  1130.      * @param int $tchat_id
  1131.      */
  1132.     private function newAdminMessageNotification($tchat_id, $message)
  1133.     {
  1134.         $tchat = $this->entityManager->getRepository(Tchat::class)->find($tchat_id);
  1135.         $customer = $this->entityManager->getRepository(EcoCustomers::class)->find($tchat->getCustomerId());
  1137.         $this->mailerService->fromEmail = $customer->getAuthUserId()->getEmail();
  1138.         $this->mailerService->fromName = $customer->getCustLastName() . ' ' . $customer->getCustFirstName();
  1139.         $this->mailerService->subject = SITE_NAME . " - Nouveau message dans votre outil de messagerie";
  1141.         $allRecipients = array();
  1142.         //        $allRecipients[] = [
  1143.         //            "nom" => SITE_NAME,
  1144.         //            "prenom" => '',
  1145.         //            "email" => 'stephen@otidea.com',
  1146.         //            "type" => 'to'
  1147.         //        ];
  1149.         $htmlContent = $this->renderView('layouts/layouts_emails/notification_tchat_admin.html.twig', [
  1150.             'tchat' => $tchat,
  1151.             'customer' => $customer,
  1152.             'message' => $message,
  1153.         ]);
  1155.         $this->mailerService->sendMail($allRecipients, $htmlContent, NULL, 'admin-notification');
  1156.     }
  1158.     #[Route(path: '/compte-client/download_attachment/{tchat_id}/{mess_id}', name: 'front_tchat_download_attachment', defaults: ['tchat_id' => '',
  1159.         'mess_id' => ''])]
  1160.     public function download_attachment(Request                 $request, TchatRepository $repoTchat,
  1161.                                         TchatMessagesRepository $repoMess, KernelInterface $appKernel, $tchat_id,
  1162.                                                                 $mess_id): Response
  1163.     {
  1164.         //Access control
  1165.         $tchat = $repoTchat->find($tchat_id);
  1166.         if ($tchat->getCustomerId() != $this->currentUserConnected->getId()) {
  1167.             return $this->redirectToRoute('front_customer_registration');
  1168.         }
  1170.         $message = $repoMess->find($mess_id);
  1172.         //Téléchargement du fichier
  1173.         $fileName = $message->getMessFile() != null ? $message->getMessFile() : 'nada.pdf';
  1174.         $file = $appKernel->getProjectDir() . '/public/medias_front/tchat/' . $fileName;
  1176.         if (file_exists($file)) {
  1177.             return new BinaryFileResponse($file);
  1178.         } else {
  1179.             return $this->redirectToRoute('front_tchat_discussion', ['tchat_id' => $tchat_id]);
  1180.         }
  1182.     }
  1184.     private function displayPopup()
  1185.     {
  1186.         if ($this->session->has('displayPopup')) {
  1188.             //Erreur de connexion
  1189.             if ($this->session->get('displayPopup') == 'connection-error') {
  1190.                 $this->otideaUtils->createPopup(["title" => 'Attention',
  1191.                         "message" => 'Votre identifiant ou votre mot de passe est incorrect',
  1192.                         "btn2" => null]
  1193.                 );
  1194.             }
  1196.             //L'adresse mail existe déjà
  1197.             if ($this->session->get('displayPopup') == 'email-exist') {
  1198.                 $this->otideaUtils->createPopup(["title" => 'Attention',
  1199.                         "message" => "L'adresse e-mail que vous voulez utiliser existe déjà. Veuillez utiliser 'Mot de passe oublié' pour récupérer votre mot de passe si vous l'avez perdu",
  1200.                         "btn2" => null]
  1201.                 );
  1202.             }
  1204.             //L'adresse mail n'est pas au bon format
  1205.             if ($this->session->get('displayPopup') == 'email-not-good') {
  1206.                 $this->otideaUtils->createPopup(["title" => 'Attention',
  1207.                         "message" => "L'adresse e-mail que vous voulez utiliser ne semble pas conforme, merci de vérifier votre saisie ou d'utiliser une autre adresse.",
  1208.                         "btn2" => null]
  1209.                 );
  1210.             }
  1212.             //Envoi d'un message
  1213.             if ($this->session->get('displayPopup') == 'send-message') {
  1214.                 $this->otideaUtils->createPopup(["title" => 'Information',
  1215.                         "message" => 'Message envoyé avec succès',
  1216.                         "btn2" => null]
  1217.                 );
  1218.             }
  1220.             //Ouverture d'un nouveau ticket
  1221.             if ($this->session->get('displayPopup') == 'open-ticket') {
  1222.                 $this->otideaUtils->createPopup(["title" => 'Information',
  1223.                         "message" => 'Ticket ouvert avec succès',
  1224.                         "btn2" => null]
  1225.                 );
  1226.             }
  1228.             $this->session->set('displayPopup', NULL);
  1229.         }
  1230.     }
  1232.     /**
  1233.      * Validates a single email address (or an array of email addresses)
  1234.      *
  1235.      * @param array|string $emails
  1236.      *
  1237.      * @return bool
  1238.      */
  1239.     public function validateEmails($emails): bool
  1240.     {
  1241.         $emails = filter_var($emails, FILTER_SANITIZE_EMAIL);
  1242.         if (filter_var($emails, FILTER_VALIDATE_EMAIL)) {
  1243.             return true;
  1244.         } else {
  1245.             return false;
  1246.         }
  1247.     }
  1249.     #[Route(path: '/compte-client/planning', name: 'front_customer_planning')]
  1250.     public function planning(Request $request, EcoPlanningRepository $planningRepository): Response
  1251.     {
  1253.         if ($this->currentUserConnected->getCustAccountType() == 'company') {
  1254.             $plannings = $planningRepository->findBy(['societyId' => $this->currentUserConnected->getId()],
  1255.                 ['deliveryStartDate' => 'ASC']);
  1256.         } else if ($this->currentUserConnected->getCustAccountType() == 'employee') {
  1257.             $plannings = $planningRepository->findBy(['societyId' => $this->currentUserConnected->getCompany()->getId()],
  1258.                 ['deliveryStartDate' => 'ASC']);
  1259.         }
  1261.         return $this->render('@main-app/front/front_customer_account/planning.html.twig', [
  1262.             'pageAccount' => 'planning',
  1263.             'plannings' => $plannings,
  1264.         ]);
  1265.     }
  1267.     #[Route(path: '/compte-client/salaries', name: 'front_customer_employee')]
  1268.     public function employee(Request $request, EcoCustomersRepository $customersRepository): Response
  1269.     {
  1271.         $employees = $customersRepository->findBy(['cust_society' => $this->currentUserConnected->getCustSociety()]);
  1273.         return $this->render('@main-app/front/front_customer_account/employee.html.twig', [
  1274.             'pageAccount' => 'employee',
  1275.             'employees' => $employees,
  1276.             'currentUser' => $this->currentUserConnected
  1277.         ]);
  1278.     }
  1280.     #[Route(path: '/inscription-salarie/{companyId}/{campanyCode}', name: 'front_customer_registration_employee', defaults: ['companyId' => '',
  1281.         'campanyCode' => ''])]
  1282.     public function inscriptionEmployee($companyId, $campanyCode, Request $request,
  1283.                                         UserPasswordHasherInterface $passwordHasher,
  1284.                                         EcoShippingfeesCountryRepository $repoCountry,
  1285.                                         EcoCustomersRepository $customersRepository): Response
  1286.     {
  1287.         if ($this->getUser()) {
  1288.             return $this->redirectToRoute('front_customer_account');
  1289.         }
  1291.         $company = $customersRepository->findOneBy(['id' => $companyId, 'custSocietyCode' => $campanyCode]);
  1293.         if ($company == null) {
  1294.             return $this->redirectToRoute('front_home');
  1295.         }
  1297.         $authUser = new AuthUser();
  1298.         $customer = new EcoCustomers();
  1300.         $form = $this->createForm(CustomerFrontType::class, $customer, [
  1301.             'authUser' => $customer->getAuthUserId(),
  1302.             'countryList' => $repoCountry->findBygCountriesOrderByFrance(),
  1303.             'userType' => 'employee',
  1304.             'newsletter' => true,
  1305.             'formType' => "newAccount",
  1306.         ]);
  1308.         $form->handleRequest($request);
  1310.         if ($form->isSubmitted() && $form->isValid()) {
  1312.             $existUser = $this->entityManager->getRepository(AuthUser::class)->findBy(['email' => $form->get('email')->getData()]);
  1314.             if ($existUser != null) {
  1315.                 $this->addFlash('danger', "Une erreur s'est produite lors de l'enregistrement");
  1316.                 return $this->redirectToRoute('front_customer_registration_employee',
  1317.                     ['companyId' => $companyId, 'campanyCode' => $campanyCode]);
  1318.             }
  1320.             $customer->setCustCreationDate(new \DateTime());
  1321.             $customer->setCustReference(uniqid());
  1323.             //Enregistrement du mot de passe
  1324.             if ($form->has('password') && $form->get('password')->getData() != "" && $form->get('password')->getData() != null) {
  1326.                 $user = $this->setEmployeeAccount($authUser->getId(), $passwordHasher, $form);
  1327.                 $customer->setAuthUserId($user);
  1329.                 // Le mot de passe n'a pas été modifié
  1330.             }
  1332.             // Compte salarié
  1333.             $customer->setCustAccountType('employee');
  1335.             // Compte confirmé
  1336.             $customer->setcustAccountStatus('confirmed');
  1338.             // FRANCE par défaut
  1339.             $customer->setCustCountryId(1);
  1341.             // reference client par défaut
  1342.             $customer->setCustReference("CLI");
  1344.             // liaison avec l'entreprise
  1345.             $customer->setCompany($company);
  1346.             $customer->setCustSociety($company->getCustSociety());
  1348.             try {
  1349.                 $this->entityManager->persist($customer);
  1350.                 $this->entityManager->flush();
  1351.                 $this->addFlash('success', "enregistré avec succès");
  1352.             } catch (Exception $ex) {
  1353.                 $this->addFlash('danger', "Cet utilisateur existe déjà");
  1354.             }
  1356.             try {
  1357.                 $ref = $customer->getId() + 1000;
  1358.                 $customer->setCustReference("CLI" . $ref);
  1359.                 $this->entityManager->persist($customer);
  1360.                 $this->entityManager->flush();
  1361.             } catch (Exception $ex) {
  1362.                 $this->addFlash('danger', "Une erreur s'est produite lors de la modification de la référence client");
  1363.             }
  1365.             return $this->redirectToRoute('front_customer_account', array('id' => $customer->getId()));
  1366.         }
  1368.         return $this->render('@main-app/security_front/registration_employee.html.twig', [
  1369.             'form' => $form->createView(),
  1370.             'company' => $company,
  1371.         ]);
  1372.     }
  1374.     /*
  1375.      * Permet d'ajouter un nouveau compte client
  1376.      * avec le role de client
  1377.      * @return bool
  1378.      */
  1379.     private function setEmployeeAccount($authUserId = 0, $passwordHasher = null, $form = null, $repoAuthUser = null)
  1380.     {
  1382.         if ($form->get('email')->getData() !== null && $form->get('password')->getData() !== null) {
  1384.             if ($authUserId > 0) {
  1385.                 $user = $repoAuthUser->find($authUserId);
  1386.             } else {
  1387.                 $user = new AuthUser();
  1388.             }
  1390.             $user->setEmail($form->get('email')->getData());
  1392.             // modification du mot de passe
  1393.             if ($form->get('password')->getData() !== null && trim($form->get('password')->getData()) != "") {
  1394.                 // hash the password (based on the security.yaml config for the $user class)
  1395.                 $hashedPassword = $passwordHasher->hashPassword(
  1396.                     $user,
  1397.                     $form->get('password')->getData()
  1398.                 );
  1400.                 $user->setPassword($hashedPassword);
  1401.             }
  1403.             if ($user->getId() == 0) {
  1404.                 $user->setRoles(array_merge($user->getRoles(), ['ROLE_CUSTOMER']));
  1405.                 $user->setCreationDatetime(new \DateTime());
  1406.             }
  1408.             $this->entityManager->persist($user);
  1409.             $this->entityManager->flush();
  1411.             return $user;
  1412.         }
  1414.         return false;
  1415.     }
  1416. }