src/Controller/GestionController.php line 82

Open in your IDE?
  1. <?php
  2. // src/Controller/EntrepriseController.php
  3. namespace App\Controller;
  4. use App\Entity\SujetFAQ;
  5. use App\Entity\Article;
  6. use App\Entity\AppUser;
  7. use App\Entity\Product;
  8. use App\Entity\Review;
  9. use App\Entity\Devis;
  10. use App\Entity\Category;
  11. use App\Entity\Commande;
  12. use App\Entity\Conversation;
  13. use App\Entity\Service;
  14. use App\Entity\ProductOrder;
  15. use App\Entity\Entreprise;
  16. use App\Entity\Notification;
  17. use App\Entity\ProductMisDeCote;
  18. use App\Entity\SubCategory;
  19. use App\Entity\AvisUtilisateur;
  20. use App\Form\SujetFAQType;
  21. use App\Form\AvisUtilisateurType;
  22. use App\Form\AvisUtilisateurEditType;
  23. use App\Form\ProductType;
  24. use App\Entity\ShippingMethod;
  25. use App\Entity\RoleBoutique;
  26. use App\Entity\Boutique;
  27. use App\Form\BoutiqueType;
  28. use App\Entity\Plan;
  29. use App\Entity\ValiditeService;
  30. use App\Entity\UserBoutique;
  31. use App\Entity\RequeteAjoutBoutique;
  32. use App\Entity\TVA;
  33. use Spipu\Html2Pdf\Html2Pdf;
  34. use App\Entity\CategorieEntreprise;
  35. use App\Entity\Produit;
  36. use App\Entity\ProductPhoto;
  37. use App\Entity\OffreDevis;
  38. use App\Form\ProduitType;
  39. use App\Form\ProduitEditType;
  40. use App\Entity\Ticket;
  41. use App\Entity\Message;
  42. use App\Services\CinetPay;
  43. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  44. use App\Form\TicketType;
  45. use App\Entity\CommentaireTicket;
  46. use App\Form\CommentaireTicketType;
  47. use App\Entity\PaiementService;
  49. use App\Form\SettingBoutiqueOngletEntrepriseType;
  50. use App\Form\SettingBoutiqueOngletBanqueType;
  51. use App\Form\SettingBoutiqueOngletInfoLegaleType;
  52. use App\Form\SettingBoutiqueOngletDocumentType;
  53. use App\Form\SettingBoutiqueOngletEmailType;
  55. use Symfony\Component\HttpFoundation\Response;
  56. use Symfony\Component\HttpFoundation\JsonResponse;
  57. use Symfony\Component\HttpFoundation\RedirectResponse;
  58. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  59. use Symfony\Component\HttpFoundation\Request;
  60. use Symfony\Component\Security\Core\Encoder\UserPasswordEncoderInterface;
  61. use Symfony\Component\Routing\Annotation\Route;
  62. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  63. use Sensio\Bundle\FrameworkExtraBundle\Configuration\Security as Security;
  65. /**
  66.  * @Route("/{_locale}/gestion")
  67.  */
  69. class GestionController extends AbstractController
  70. {    
  71.     private $session;
  72.     
  73.     public function __construct(SessionInterface $session)
  74.     {
  75.         $this->session = $session;
  76.     }
  77.     
  78.     /**
  79.      * @Route("/mes-entreprises/", name="gestion_mes_entreprises")
  80.      * @return \Symfony\Component\HttpFoundation\Response
  81.      */
  82.     public function mesEntrepriseAction(Request $request)
  83.     {
  84.         $em = $this->getDoctrine()
  85.                     ->getManager();
  86.     
  87.         $user = $this->getUser();
  88.         $userBoutiques = $em->getRepository(UserBoutique::class)
  89.                         ->findByUser($user);
  90.         return $this->render('gestion/mes_entreprise.html.twig', [
  91.             'userBoutiques' => $userBoutiques
  92.         ]);
  93.     }
  94.     
  95.     
  96.     /**
  97.      * @Route("/shop/{slug}", name="gestion.show_shop")
  98.      * @return \Symfony\Component\HttpFoundation\Response
  99.      */
  100.     public function afficherBoutiqueAction(Request $request, Boutique $boutique)
  101.     {
  102.         $em = $this->getDoctrine()
  103.                     ->getManager();
  104.         $user = $this->getUser();
  105.         $userBoutique = $em->getRepository(UserBoutique::class)
  106.                         ->findOneBy(
  107.                             array(
  108.                             'user' => $user->getId(),
  109.                             'boutique' => $boutique->getId()
  110.                             )
  111.                         );
  112.         
  113.         if(null == $userBoutique){
  114.             return $this->redirectToRoute('security_login');
  115.         }
  117.         $abonnement = $em->getRepository(Commande::class)
  118.                         ->findBy(
  119.                             array(
  120.                                 'boutique' => $boutique 
  121.                             ),
  122.                             array(
  123.                                 'laDate' => 'DESC'
  124.                             ),
  125.                             1
  126.                         );    
  127.         if(!empty($abonnement)){
  128.             $abonnement = $abonnement[0];
  129.         }
  130.             
  131.         return $this->render('gestion/afficher_boutique.html.twig', [
  132.             'boutique' => $boutique,
  133.             'userBoutique' => $userBoutique,
  134.             'abonnement' => $abonnement
  135.             
  136.         ]);
  137.     }
  138.     
  139.     /**
  140.      * @Route("/devenir-premium/", name="gestion.devenir_premium")
  141.      * @return \Symfony\Component\HttpFoundation\Response
  142.      */
  143.     public function devenirPremiumAction(Request $request, Boutique $boutique)
  144.     {
  145.         $em = $this->getDoctrine()
  146.                     ->getManager();
  147.                     
  148.         $user = $this->getUser();
  149.         $userBoutique = $em->getRepository(UserBoutique::class)
  150.                         ->findOneBy(
  151.                             array(
  152.                             'user' => $user->getId(),
  153.                             'boutique' => $boutique->getId()
  154.                             )
  155.                         );
  156.         $transId = rand(4560, 100000);
  157.         $transDate = new \DateTime();
  158.         $amount = 15000;
  159.         if('POST' == $request->getMethod()){
  160.             var_dump($_POST);
  161.         }
  162.         
  163.         
  164.     $commande = new Commande;
  165.     //transaction id
  166.     $id_transaction = rand(); //CinetPay::generateTransId();
  167.     // Payment description
  168.     $description_du_paiement = "Devenir premium";
  169.     // Payment Date must be on date format
  170.     $date_transaction = date("Y-m-d H:i:s");
  171.     // Amount
  172.     $montant_a_payer = 15000;
  174.     // put a value that you can use to identify the buyer in your system
  175.     $identifiant_du_payeur = $user->getId().'@@@'.$boutique->getId();
  177.     //Veuillez entrer votre apiKey
  178.     $apiKey = "1182873575626ba8e6c712e9.05305545";
  179.     //Secret Key: 127127447062796bafS
  180.     //Veuillez entrer votre siteId
  181.     $site_id = "792421";
  183.     //platform ,  utiliser PROD si vous avez créé votre compte sur www.cinetpay.com  ou TEST si vous avez créé votre compte sur www.sandbox.cinetpay.com
  184.     $plateform = "PROD";
  186.     //la version ,  utilisé V1 si vous voulez utiliser la version 1 de l'api
  187.     $version = "V2";
  189.     // nom du formulaire CinetPay
  190.     $formName = "goCinetPay";
  191.     // notify url
  192.     $notify_url = $this->generateUrl('gestion.cinetpay_notify', array('transaction' => $id_transaction), UrlGeneratorInterface::ABSOLUTE_URL);
  193.     // return url
  194.     $return_url =  $this->generateUrl('gestion.cinetpay_return', array('transaction' => $id_transaction), UrlGeneratorInterface::ABSOLUTE_URL);
  195.     // cancel url
  196.     $cancel_url =  $this->generateUrl('gestion.cinetpay_cancel', array('transaction' => $id_transaction), UrlGeneratorInterface::ABSOLUTE_URL);
  198.     // cinetpay button type, must be 1, 2, 3, 4 or 5
  199.     $btnType = 4;
  200.     // button size, can be 'small' , 'large' or 'larger'
  201.     $btnSize = 'large';
  202.     // fill command class
  203.     $commande->setCpmTransId($id_transaction);
  204.     $commande->setCpmAmount($montant_a_payer);
  205.     $commande->setUser($user);
  206.     $commande->setBoutique($boutique);
  208.     $em->persist($commande);
  209.     $em->flush();
  211.    
  212.         return $this->render('gestion/devenir_premium.html.twig', [
  213.             'user' => $user,
  214.             'transId' => $transId,
  215.             'transDate' => $transDate,
  216.             'amount' => $amount,
  217.             'plan' => $plan,
  218.             'transaction' => $id_transaction,
  219.             'formName' => $formName,
  220.             'btnType' => $btnType,
  221.             'btnSize' => $btnSize,
  222.             'boutique' => $boutique,
  223.             'userBoutique' => $userBoutique,
  224.         ]);
  225.         
  226.         return $this->redirectToRoute('gestion.show_shop', array('slug' => $boutique->getSlug()));
  227.             
  228.     }
  230.     /**
  231.      * @Route("/table-formule-pour-paiement/{slug}", name="gestion_table_formule_pour_paiement")
  232.      * @return \Symfony\Component\HttpFoundation\Response
  233.      */
  234.     public function tableFormulePourPaiementAction(Request $request, Boutique $boutique)
  235.     {
  236.         $em = $this->getDoctrine()
  237.                     ->getManager();
  238.                     
  239.         $plans = $em->getRepository(Plan::class)
  240.                     ->paidPlan();
  243.         return $this->render('gestion/table_formule_pour_paiement.html.twig', [
  244.             'boutique' => $boutique,
  245.             'plans' => $plans
  246.         ]);
  247.     }
  249.     /**
  250.      * @Route("/paiement-abonnement/{idEntreprise}/{idPlan}/{idUser}/{plateforme}", name="gestion_paiement_abonnement")
  251.      * @return \Symfony\Component\HttpFoundation\Response
  252.      */
  253.     public function paiementAbonnementAction(Request $request,  $idEntreprise, $idPlan, $idUser, $plateforme)
  254.     {
  255.         $em = $this->getDoctrine()
  256.                     ->getManager();
  258.         $user = $this->getUser();
  259.         $boutique =  $em->getRepository(Boutique::class)
  260.                         ->findOneById($idEntreprise);
  262.         if($plateforme == 'mobile'){
  263.             $user =  $em->getRepository(AppUser::class)
  264.                         ->findOneById($idUser);
  265.         }
  266.         
  267.         $userBoutique = $em->getRepository(UserBoutique::class)
  268.                         ->findOneBy(
  269.                             array(
  270.                             'user' => $user->getId(),
  271.                             'boutique' => $boutique->getId()
  272.                             )
  273.                         );
  275.         if(null == $userBoutique){
  276.             return $this->createNotFoundException();
  277.         }
  279.         $plan = $em->getRepository(Plan::class)
  280.                     ->findOneById($idPlan);
  282.         //Authentification
  283.     /*
  284.     $ch = curl_init($this->getJekoBaseUrl().'/stores');
  285.     curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  286.     curl_setopt($ch, CURLOPT_HTTPHEADER, [
  287.         'X-API-KEY:'. $this->getJekoAPI(),
  288.         'X-API-KEY-ID:'.$this->getJekoAPIID(),
  289.         'Content-Type: application/json'
  290.     ]);
  294.     
  295.     $response = curl_exec($ch);
  296.     curl_close($ch);
  297.     $paymentRequest = json_decode($response, true);
  298.     
  299.     */
  302.         $transId = rand(4560, 100000);
  303.         $transDate = new \DateTime();
  304.         $amount = 15000;
  305.         $message = '';
  306.         $error = '';
  307.         $qrUrl = '';
  308.         $authenticationUrl = 'https://billpayment.api.prod.run.billmap.net/api/authentication/token';
  310.         $id_transaction = '';
  312.         $apiKeyAndSecret = array(
  313.             'orangekey' => '2CSLsG7IDYHmR8Wp',
  314.             'orangesecret' => '3puc5vA7cySjUGoCkAJZ5nzIesMg0uWdLVsNchbvClZz8ZqtBwzz1bdOMSxnWEzF',
  316.             'mtnkey' => '3AXHb9Q0ctzSJqbV',
  317.             'mtnsecret' => 'oDXwYw4XwervcUHof7u7M0tRfRuAYf9aGmgOWYF9y1aMjkWX3lZx312X5ge8L8I9',
  319.             'moovkey' => 'GX7fNUtKpzbaZbrM',
  320.             'moovesecret' => '2OZpbuvcRCDNapJrsVkHTE6gqocNdeN1DxIQIlEpBZjbR6GuQaBYkbim05fDbK1i',
  322.             'wavekey' => '2CSLsG7IDYHmR8Wp',
  323.             'wavesecret' => '3puc5vA7cySjUGoCkAJZ5nzIesMg0uWdLVsNchbvClZz8ZqtBwzz1bdOMSxnWEzF'
  324.         );
  325.         
  326.         //variable mise pour la compatibilité mobile
  327.         $keyOperateur = array(
  328.             'orangekey' => '2CSLsG7IDYHmR8Wp',
  329.             'orangesecret' => '3puc5vA7cySjUGoCkAJZ5nzIesMg0uWdLVsNchbvClZz8ZqtBwzz1bdOMSxnWEzF',
  330.             'orangedebiturl' => 'https://billpayment.api.prod.run.billmap.net/api/Bill/orange/webpayment',
  331.             'orangecode' => 'MYHELPPLACE_ORANGE',
  333.             'mtnkey' => '2CSLsG7IDYHmR8Wp',
  334.             'mtnsecret' => '3puc5vA7cySjUGoCkAJZ5nzIesMg0uWdLVsNchbvClZz8ZqtBwzz1bdOMSxnWEzF',
  335.             'mtndebiturl' => 'https://billpayment.api.prod.run.billmap.net/api/Bill/debit/openapi',
  336.             'mtncode' => 'MYHELPPLACE_MTNCI',
  338.             'moovkey' => 'GX7fNUtKpzbaZbrM',
  339.             'moovsecret' => '2OZpbuvcRCDNapJrsVkHTE6gqocNdeN1DxIQIlEpBZjbR6GuQaBYkbim05fDbK1i',
  340.             'moovdebiturl' =>'https://billpayment.api.prod.run.billmap.net/api/Bill/debit/moov',
  341.             'moovcode' => 'MYHELPPLACE_MOOVCI',
  343.             'wavekey' => '2CSLsG7IDYHmR8Wp',
  344.             'wavesecret' => '3puc5vA7cySjUGoCkAJZ5nzIesMg0uWdLVsNchbvClZz8ZqtBwzz1bdOMSxnWEzF',
  345.             'wavedebiturl' => 'https://billpayment.api.prod.run.billmap.net/api/bill/wave/checkout',
  346.             'wavecode' => 'MYHELPPLACE_WAVE'
  347.         );
  348.         
  349.         if('POST' == $request->getMethod()){
  351.             $formData = json_decode($request->getContent());
  353.             if($plateforme == 'web'){
  354.                 $operateurPaiement = $request->request->get('operateur_paiement');
  355.                 $numeroDeTelephone = $request->request->get('numero_de_telephone');
  356.                 $indicatifPays = $request->request->get('indicatif_pays');
  357.                 $mois = (float)$request->request->get('mois');
  359.                 //$montantTransaction = (float)$request->request->get('montant_transaction');
  361.                 $montantTransaction = $plan->getTarif() * $mois;
  363.                 $key = $request->request->get($operateurPaiement.'key');
  364.                 $secret =  $request->request->get($operateurPaiement.'secret');
  365.                 $debitURL =  $request->request->get($operateurPaiement.'debiturl');
  366.                 $code =  $request->request->get($operateurPaiement.'code');
  367.                 $otp = $request->request->get('otp');
  369.             }else{
  370.                 // mobile
  371.             
  372.                 $operateurPaiement = $formData->operateur_paiement;
  373.                 $numeroDeTelephone = $formData->numero_de_telephone;
  374.                 $indicatifPays = $formData->indicatif_pays;
  375.                 $mois = (float)$formData->mois;
  377.                 //$montantTransaction = (float)$formData->montant_transaction;
  379.                 $montantTransaction = $plan->getTarif() * $mois;
  381.                 $key = $keyOperateur[$operateurPaiement.'key'];
  382.                 $secret =  $keyOperateur[$operateurPaiement.'secret'];
  383.                 $debitURL =  $keyOperateur[$operateurPaiement.'debiturl'];
  384.                 $code =  $keyOperateur[$operateurPaiement.'code'];
  386.                 $otp = $formData->otp;
  388.             }        
  389.             
  391.             $id_transaction = '';
  392.             
  394.                 $commande = new Commande;
  395.                 $commande->setPlan($plan);
  397.                 //transaction id
  398.                 
  399.                 // Payment description
  400.                 $description_du_paiement = "Devenir premium";
  401.                 // Payment Date must be on date format
  402.                 $date_transaction = date("Y-m-d H:i:s");
  403.                 // Amount
  404.                 $montant_a_payer = $montantTransaction;
  406.                 // put a value that you can use to identify the buyer in your system
  407.                 $identifiant_du_payeur = $user->getId().'@@@'.$boutique->getId();
  409.                 $commande->setCpmTransId($id_transaction);
  410.                 $commande->setCpmAmount($montant_a_payer);
  411.                 $commande->setUser($user);
  412.                 $commande->setBoutique($boutique);
  413.                 $em->persist($commande);
  415.                 $em->flush();
  416.                 $laReference =  $commande->getId().'@ABONNEMENT'.'@'.$mois;
  417.                 // notify url
  418.                 $returnUrls = $this->getJekoReturnUrls($laReference, $plateforme);
  419.                 $successUrl = $returnUrls['successUrl'];
  420.                 // return url
  421.                 $errorUrl = $returnUrls['errorUrl'];
  422.                 
  424.                 $ch = curl_init($this->getJekoBaseUrl().'/payment_requests');
  425.                 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  426.                 curl_setopt($ch, CURLOPT_POST, true);
  427.                 curl_setopt($ch, CURLOPT_HTTPHEADER, [
  428.                     'X-API-KEY:'. $this->getJekoAPI(),
  429.                     'X-API-KEY-ID:'.$this->getJekoAPIID(),
  430.                     'Content-Type: application/json'
  431.                 ]);
  433.                 $amountCents = (int) round((float) $montantTransaction * 100);
  434.                 
  435.                 curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
  436.                     'storeId' => $this->getJekoStoreId(),
  437.                     'amountCents' => $amountCents,
  438.                     'currency' => 'XOF',
  439.                     'reference' =>$laReference,
  440.                     'paymentDetails' => [
  441.                         'type' => 'redirect',
  442.                         'data' => [
  443.                             'paymentMethod' => $operateurPaiement,
  444.                             'successUrl' => $successUrl,
  445.                             'errorUrl' => $errorUrl
  446.                         ]
  447.                     ]
  448.                 ]));
  450.                 
  451.                 $response = curl_exec($ch);
  452.                 $curlError = curl_error($ch);
  453.                 $httpCode = (int)curl_getinfo($ch, CURLINFO_HTTP_CODE);
  454.                 curl_close($ch);
  455.                 $paymentRequest = json_decode($response, true);
  457.                 if ($response === false || $curlError || !is_array($paymentRequest) || empty($paymentRequest['redirectUrl'])) {
  458.                     return $this->allowRemoteRequest(new JsonResponse([
  459.                         'error' => 'Unable to create Jèko payment',
  460.                         'providerStatus' => $httpCode,
  461.                     ], Response::HTTP_BAD_GATEWAY));
  462.                 }
  463.                 
  464.                 $commande->setCpmTransId($paymentRequest['id'] ?? $id_transaction);
  465.                 $commande->setCpmAmount($montant_a_payer);
  466.                 $em->flush();
  468.                 if($plateforme == 'web'){
  469.                     return $this->redirect($paymentRequest['redirectUrl']);
  470.                 }else{
  472.                     return $this->allowRemoteRequest(new JsonResponse([
  473.                         'error' => '',
  474.                         'message' => '',
  475.                         'redirectUrl' => $paymentRequest['redirectUrl'],
  476.                         'reference' => $laReference,
  477.                         'paymentReference' => $laReference,
  478.                         'successUrl' => $successUrl,
  479.                         'errorUrl' => $errorUrl,
  480.                     ]));
  481.                 }
  483.                 return $this->redirectToRoute('gestion_finaliser_abonnement', array('slug' => $boutique->getSlug(), 'plan' => $plan->getSlug()));
  485.             
  486.         }
  487.         
  488.         if($plateforme == 'mobile'){
  489.             return $this->render('api/paiement_abonnement.html.twig', [
  490.                 'user' => $user,
  491.                 'transId' => $transId,
  492.                 'transDate' => $transDate,
  493.                 'amount' => $amount,
  494.                 'plan' => $plan,
  495.                 'boutique' => $boutique,
  496.                 'userBoutique' => $userBoutique,
  497.                 'transaction' => $id_transaction,
  498.                 'keyOperateur' => $keyOperateur
  499.                 ]);
  500.         }
  502.         return $this->render('gestion/paiement_abonnement.html.twig', [
  503.             'user' => $user,
  504.             'transId' => $transId,
  505.             'transDate' => $transDate,
  506.             'amount' => $amount,
  507.             //'CinetPay' => $CinetPay,
  508.             'plan' => $plan,
  509.             'boutique' => $boutique,
  510.             'userBoutique' => $userBoutique,
  511.             'transaction' => $id_transaction
  512.         ]);    
  513.     }
  515.     /**
  516.      * @Route("/paiement-frais-de-service/{idUser}/{typeService}/{plateforme}", name="gestion_paiement_frais_de_service")
  517.      * @return \Symfony\Component\HttpFoundation\Response
  518.     */
  519.     public function paiementFraisDeServiceAction(Request $request,  $idUser, $typeService, $plateforme)
  520.     {
  521.         $em = $this->getDoctrine()
  522.                     ->getManager();
  524.         $user = $em->getRepository(AppUser::class)
  525.                     ->findOneById($idUser);
  526.         
  527.         if(null == $user){
  528.             throw $this->createNotFoundException();
  529.         }
  530.         
  531.         $transId = rand(4560, 100000);
  532.         $transDate = new \DateTime();
  533.         $amount = 15000;
  534.         $message = '';
  535.         $error = '';
  536.         $qrUrl = '';
  538.         $authenticationUrl = 'https://billpayment.api.prod.run.billmap.net/api/authentication/token';
  540.         $id_transaction = '';
  542.         $apiKeyAndSecret = array(
  543.             'orangekey' => '2CSLsG7IDYHmR8Wp',
  544.             'orangesecret' => '3puc5vA7cySjUGoCkAJZ5nzIesMg0uWdLVsNchbvClZz8ZqtBwzz1bdOMSxnWEzF',
  546.             'mtnkey' => '3AXHb9Q0ctzSJqbV',
  547.             'mtnsecret' => 'oDXwYw4XwervcUHof7u7M0tRfRuAYf9aGmgOWYF9y1aMjkWX3lZx312X5ge8L8I9',
  549.             'moovkey' => 'GX7fNUtKpzbaZbrM',
  550.             'moovesecret' => '2OZpbuvcRCDNapJrsVkHTE6gqocNdeN1DxIQIlEpBZjbR6GuQaBYkbim05fDbK1i',
  552.             'wavekey' => '2CSLsG7IDYHmR8Wp',
  553.             'wavesecret' => '3puc5vA7cySjUGoCkAJZ5nzIesMg0uWdLVsNchbvClZz8ZqtBwzz1bdOMSxnWEzF'
  554.         );
  556.         //variable mise pour la compatibilité mobile
  557.         $keyOperateur = array(
  558.             'orangekey' => '2CSLsG7IDYHmR8Wp',
  559.             'orangesecret' => '3puc5vA7cySjUGoCkAJZ5nzIesMg0uWdLVsNchbvClZz8ZqtBwzz1bdOMSxnWEzF',
  560.             'orangedebiturl' => 'https://billpayment.api.prod.run.billmap.net/api/Bill/orange/webpayment',
  561.             'orangecode' => 'MYHELPPLACE_ORANGE',
  563.             'mtnkey' => '2CSLsG7IDYHmR8Wp',
  564.             'mtnsecret' => '3puc5vA7cySjUGoCkAJZ5nzIesMg0uWdLVsNchbvClZz8ZqtBwzz1bdOMSxnWEzF',
  565.             'mtndebiturl' => 'https://billpayment.api.prod.run.billmap.net/api/Bill/debit/openapi',
  566.             'mtncode' => 'MYHELPPLACE_MTNCI',
  568.             'moovkey' => 'GX7fNUtKpzbaZbrM',
  569.             'moovsecret' => '2OZpbuvcRCDNapJrsVkHTE6gqocNdeN1DxIQIlEpBZjbR6GuQaBYkbim05fDbK1i',
  570.             'moovdebiturl' =>'https://billpayment.api.prod.run.billmap.net/api/Bill/debit/moov',
  571.             'moovcode' => 'MYHELPPLACE_MOOVCI',
  572.             
  573.             'wavekey' => '2CSLsG7IDYHmR8Wp',
  574.             'wavesecret' => '3puc5vA7cySjUGoCkAJZ5nzIesMg0uWdLVsNchbvClZz8ZqtBwzz1bdOMSxnWEzF',
  575.             'wavedebiturl' => 'https://billpayment.api.prod.run.billmap.net/api/bill/wave/checkout',
  576.             'wavecode' => 'MYHELPPLACE_WAVE'
  577.         );
  579.         if('POST' == $request->getMethod()){
  581.             $formData = json_decode($request->getContent(), true);
  582.             if (!is_array($formData)) {
  583.                 $formData = $request->request->all();
  584.             }
  585.             $getInput = static function (array $data, string $camel, ?string $snake = null) {
  586.                 return $data[$camel] ?? ($snake !== null ? ($data[$snake] ?? null) : null);
  587.             };
  589.             if($plateforme == 'web'){
  591.                 $operateurPaiement = strtolower(trim((string)$request->request->get('operateurPaiement')));
  592.                 $numeroDeTelephone = $request->request->get('numeroDeTelephone');
  593.                 $indicatifPays = $request->request->get('indicatifPays');
  595.                 $montantTransaction = (float)$request->request->get('montant');
  597.                 $key = $request->request->get($operateurPaiement.'key');
  598.                 $secret =  $request->request->get($operateurPaiement.'secret');
  599.                 $debitURL =  $request->request->get($operateurPaiement.'debiturl');
  600.                 $code =  $request->request->get($operateurPaiement.'code');
  601.                 $otp = $request->request->get('otp');
  603.             }else{
  604.                 // mobile
  605.             
  606.                 $operateurPaiement = strtolower(trim((string)$getInput($formData, 'operateurPaiement', 'operateur_paiement')));
  607.                 $numeroDeTelephone = $getInput($formData, 'numeroDeTelephone', 'numero_de_telephone');
  608.                 $indicatifPays = $getInput($formData, 'indicatifPays', 'indicatif_pays');
  610.                 $montantTransaction = (float)$getInput($formData, 'montant');
  612.                 $key = $keyOperateur[$operateurPaiement.'key'] ?? null;
  613.                 $secret =  $keyOperateur[$operateurPaiement.'secret'] ?? null;
  614.                 $debitURL =  $keyOperateur[$operateurPaiement.'debiturl'] ?? null;
  615.                 $code =  $keyOperateur[$operateurPaiement.'code'] ?? null;
  617.                 $otp = $getInput($formData, 'otp');
  619.             }
  620.             
  622.                 $id_transaction = '';
  623.         
  625.                 $paiementService = new PaiementService;
  626.                 $paiementService->setMontant($montantTransaction);
  627.                 $paiementService->setUser($user);
  628.                 $requestedPaymentType = strtoupper(trim((string)$typeService));
  629.                 if ($requestedPaymentType === 'PRESTATION') {
  630.                     $paymentType = 'PRESTATION';
  631.                 } elseif (in_array($requestedPaymentType, ['DISCUTER', 'DISCUSSION'], true)) {
  632.                     $paymentType = 'DISCUSSION';
  633.                 } elseif (in_array($requestedPaymentType, ['DEVIS', 'DEMANDE_DEVIS', 'DEMANDE-DE-DEVIS'], true)) {
  634.                     $paymentType = 'DEVIS';
  635.                 } else {
  636.                     $paymentType = 'SERVICE';
  637.                 }
  638.                 $idOffreDevis = $plateforme === 'web'
  639.                     ? $request->request->get('idOffreDevis')
  640.                     : ($getInput($formData, 'idOffreDevis', 'id_offre_devis')
  641.                         ?? $getInput($formData, 'offreDevisId', 'offre_devis_id'));
  642.                 $offreDevis = $idOffreDevis
  643.                     ? $em->getRepository(OffreDevis::class)->findOneById($idOffreDevis)
  644.                     : null;
  645.                 if ($offreDevis) {
  646.                     $clientDuDevis = $offreDevis->getDevis() ? $offreDevis->getDevis()->getUser() : null;
  647.                     if (!$clientDuDevis || (int) $clientDuDevis->getId() !== (int) $user->getId()) {
  648.                         return $this->allowRemoteRequest(new JsonResponse([
  649.                             'error' => 'Accès refusé',
  650.                             'message' => 'Ce devis appartient à un autre compte client.',
  651.                         ], Response::HTTP_FORBIDDEN));
  652.                     }
  653.                     $paymentType = 'PRESTATION';
  654.                     $montantTransaction = $this->montantFinalOffre($offreDevis);
  655.                 }
  656.                 if (in_array($paymentType, ['DISCUSSION', 'DEVIS'], true)
  657.                     && $this->paiementFraisDuJourExiste($em, $user, $paymentType)) {
  658.                     return $this->allowRemoteRequest(new JsonResponse([
  659.                         'error' => 'Frais déjà demandés',
  660.                         'message' => 'Les frais de ' . strtolower($paymentType) . ' ne peuvent être demandés qu’une seule fois par jour.',
  661.                         'typeService' => $paymentType,
  662.                     ], Response::HTTP_CONFLICT));
  663.                 }
  664.                 if (!$operateurPaiement || $montantTransaction <= 0 || !isset($keyOperateur[$operateurPaiement.'key'])) {
  665.                     return $this->allowRemoteRequest(new JsonResponse(['error' => 'Invalid payment parameters'], Response::HTTP_BAD_REQUEST));
  666.                 }
  667.                 // Le montant final vient toujours de l'offre pour une prestation.
  668.                 $paiementService->setMontant($montantTransaction);
  669.                 $paiementService->setTypeService($paymentType);
  670.                 $paiementService->setLaDate(new \DateTime());
  671.                 if ($paymentType === 'PRESTATION') {
  672.                     if (!$offreDevis || !$offreDevis->getBoutique()) {
  673.                         return $this->allowRemoteRequest(new JsonResponse([
  674.                             'error' => 'idOffreDevis obligatoire pour un paiement de prestation',
  675.                         ], Response::HTTP_BAD_REQUEST));
  676.                     }
  677.                     $paiementService->setOffreDevis($offreDevis);
  678.                 }
  679.                 //transaction id
  680.                 
  681.                 // Payment description
  682.                 $description_du_paiement = "Devenir premium";
  683.                 // Payment Date must be on date format
  684.                 $date_transaction = date("Y-m-d H:i:s");
  685.                 // Amount
  686.                 $montant_a_payer = $montantTransaction;
  689.                 //$commande->setCpmTransId($id_transaction);
  690.                 //$commande->setCpmAmount($montant_a_payer);
  691.                 //$commande->setUser($user);
  692.                 $em->persist($paiementService);
  694.                 $em->flush();    
  695.                 
  696.                 $laReference = $paiementService->getId() . '@' . $paymentType;
  697.                 if ($paymentType === 'PRESTATION' && $offreDevis) {
  698.                     $laReference .= '@' . $offreDevis->getId();
  699.                 }
  700.                 // notify url
  701.                 $returnUrls = $this->getJekoReturnUrls($laReference, $plateforme);
  702.                 $successUrl = $returnUrls['successUrl'];
  703.                 // return url
  704.                 $errorUrl = $returnUrls['errorUrl'];
  705.                 
  707.                 $ch = curl_init($this->getJekoBaseUrl().'/payment_requests');
  708.                 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  709.                 curl_setopt($ch, CURLOPT_POST, true);
  710.                 curl_setopt($ch, CURLOPT_HTTPHEADER, [
  711.                     'X-API-KEY:'. $this->getJekoAPI(),
  712.                     'X-API-KEY-ID:'.$this->getJekoAPIID(),
  713.                     'Content-Type: application/json'
  714.                 ]);
  716.                 $amountCents = (int) round((float) $montantTransaction * 100);
  717.                 
  718.                 curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
  719.                     'storeId' => $this->getJekoStoreId(),
  720.                     'amountCents' => $amountCents,
  721.                     'currency' => 'XOF',
  722.                     'reference' =>$laReference,
  723.                     'paymentDetails' => [
  724.                         'type' => 'redirect',
  725.                         'data' => [
  726.                             'paymentMethod' => $operateurPaiement,
  727.                             'successUrl' => $successUrl,
  728.                             'errorUrl' => $errorUrl
  729.                         ]
  730.                     ]
  731.                 ]));
  733.                 
  734.                 $response = curl_exec($ch);
  735.                 $curlError = curl_error($ch);
  736.                 $httpCode = (int)curl_getinfo($ch, CURLINFO_HTTP_CODE);
  737.                 curl_close($ch);
  738.                 $paymentRequest = json_decode($response, true);
  740.                 if ($response === false || $curlError || !is_array($paymentRequest) || empty($paymentRequest['redirectUrl'])) {
  741.                     $providerMessage = is_array($paymentRequest)
  742.                         ? ($paymentRequest['message'] ?? $paymentRequest['error'] ?? 'Jèko n’a pas fourni de redirectUrl')
  743.                         : 'Réponse Jèko invalide';
  744.                     $providerResponse = is_array($paymentRequest) ? $paymentRequest : ['raw' => substr((string)$response, 0, 2000)];
  745.                     $providerDetails = $providerResponse['extras'] ?? $providerResponse['errors'] ?? $providerResponse['errorReason'] ?? null;
  746.                     if ($providerDetails !== null) {
  747.                         $providerMessage .= ' - ' . (is_string($providerDetails) ? $providerDetails : json_encode($providerDetails));
  748.                     }
  749.                     return $this->allowRemoteRequest(new JsonResponse([
  750.                         'error' => 'Unable to create Jèko payment',
  751.                         'message' => $providerMessage,
  752.                         'details' => $providerDetails,
  753.                         'providerResponse' => $providerResponse,
  754.                         'providerStatus' => $httpCode,
  755.                     ], Response::HTTP_BAD_GATEWAY));
  756.                 }
  757.                 
  758.                 
  761.                 $paiementService->setCpmTransId($paymentRequest['id'] ?? $id_transaction);
  762.                 $em->flush();
  764.                 if($plateforme == 'web'){
  765.                     return $this->redirect($paymentRequest['redirectUrl']);
  766.                 }else{
  768.                 
  769.                     $data = array(
  770.                             'error' => '',
  771.                             'message' => '',
  772.                             'redirectUrl' => $paymentRequest['redirectUrl'],
  773.                             'successUrl' => $successUrl,
  774.                             'errorUrl' => $errorUrl,
  775.                             'reference' => $laReference,
  776.                             'paymentReference' => $laReference
  777.                             
  778.                     );
  779.                     
  780.                     $response = new JsonResponse;
  781.         
  782.                     $response = $this->allowRemoteRequest($response);
  783.                     
  784.                     $response->setContent(json_encode($data));
  785.                     return $response;
  786.                 }
  788.                 $em->flush();
  790.                 
  791.                 //return $this->redirectToRoute('gestion_finaliser_abonnement', array('slug' => $boutique->getSlug(), 'plan' => $plan->getSlug()));
  793.             
  794.         }
  795.         
  796.         if($plateforme == 'mobile'){
  797.             return $this->render('api/paiement_service.html.twig', [
  798.                 
  799.                 ]);
  800.         }
  802.         return $this->render('gestion/paiement_abonnement.html.twig', [
  803.             'user' => $user,
  804.             'transId' => $transId,
  805.             'transDate' => $transDate,
  806.             'amount' => $amount,
  807.             
  808.             
  809.             'boutique' => $boutique,
  810.             'userBoutique' => $userBoutique,
  811.             'transaction' => $id_transaction
  812.         ]);    
  814.         if($request->getMethod() == 'POST'){
  815.             
  817.             $formData = json_decode($request->getContent());
  818.             
  819.             $dateDebut = $formData->dateDebut;
  820.             $dateDebut = new \DateTime($dateDebut);
  821.             $dateDebut->setTime(0, 0);
  822.             
  824.             $dateFin = $formData->dateFin;
  825.             //$dateFin = $request->request->get('dateFin');
  826.             
  827.             $dateFin = new \DateTime($dateFin);
  828.             $dateFin->setTime(23, 59);
  830.             $demandeRetraits = $em->getRepository(DemandeRetrait::class)
  831.                                 ->demandeDUnePeriode($boutique->getId(), $dateDebut, $dateFin, true);
  833.         }
  835.         $data = array(
  836.                 'error' => '',
  837.                 'message' => '',
  838.                 'demandeRetraits' => $demandeRetraits
  839.                 
  840.         );
  841.         $response = new JsonResponse;
  842.         
  843.         $response = $this->allowRemoteRequest($response);
  844.         
  845.         $response->setContent(json_encode($data));
  846.         return $response;
  847.         
  848.         return $this->render('api/envoyer_push_notification.html.twig', [ 
  849.             
  850.         ]);        
  851.     }
  853.     /**
  854.      * @Route("/paiement-prestation/{idUser}/{idOffreDevis}/{plateforme}", name="gestion_paiement_de_prestation")
  855.      * @return \Symfony\Component\HttpFoundation\Response
  856.     */
  857.     public function paiementPrestationAction(Request $request,  $idUser, $idOffreDevis, $plateforme)
  858.     {
  859.         $em = $this->getDoctrine()
  860.                     ->getManager();
  862.         $user = $em->getRepository(AppUser::class)
  863.                     ->findOneById($idUser);
  864.         
  865.         if(null == $user){
  866.             return $this->createNotFoundException();
  867.         }
  869.         $offreDevis =  $em->getRepository(OffreDevis::class)
  870.                     ->findOneById($idOffreDevis);
  871.         if (!$offreDevis || !$offreDevis->getBoutique()) {
  872.             return new JsonResponse(['error' => 'Offre de devis introuvable ou sans prestataire'], Response::HTTP_BAD_REQUEST);
  873.         }
  874.         $clientDuDevis = $offreDevis->getDevis() ? $offreDevis->getDevis()->getUser() : null;
  875.         if (!$clientDuDevis || (int) $clientDuDevis->getId() !== (int) $user->getId()) {
  876.             return new JsonResponse([
  877.                 'error' => 'Accès refusé',
  878.                 'message' => 'Ce devis appartient à un autre compte client.',
  879.             ], Response::HTTP_FORBIDDEN);
  880.         }
  881.         
  882.         $transId = rand(4560, 100000);
  883.         $transDate = new \DateTime();
  884.         $amount = 15000;
  885.         $message = '';
  886.         $error = '';
  887.         $qrUrl = '';
  889.         $authenticationUrl = 'https://billpayment.api.prod.run.billmap.net/api/authentication/token';
  891.         $id_transaction = '';
  893.         $apiKeyAndSecret = array(
  894.             'orangekey' => '2CSLsG7IDYHmR8Wp',
  895.             'orangesecret' => '3puc5vA7cySjUGoCkAJZ5nzIesMg0uWdLVsNchbvClZz8ZqtBwzz1bdOMSxnWEzF',
  897.             'mtnkey' => '3AXHb9Q0ctzSJqbV',
  898.             'mtnsecret' => 'oDXwYw4XwervcUHof7u7M0tRfRuAYf9aGmgOWYF9y1aMjkWX3lZx312X5ge8L8I9',
  900.             'moovkey' => 'GX7fNUtKpzbaZbrM',
  901.             'moovesecret' => '2OZpbuvcRCDNapJrsVkHTE6gqocNdeN1DxIQIlEpBZjbR6GuQaBYkbim05fDbK1i',
  903.             'wavekey' => '2CSLsG7IDYHmR8Wp',
  904.             'wavesecret' => '3puc5vA7cySjUGoCkAJZ5nzIesMg0uWdLVsNchbvClZz8ZqtBwzz1bdOMSxnWEzF'
  905.         );
  907.         //variable mise pour la compatibilité mobile
  908.         $keyOperateur = array(
  909.             'orangekey' => '2CSLsG7IDYHmR8Wp',
  910.             'orangesecret' => '3puc5vA7cySjUGoCkAJZ5nzIesMg0uWdLVsNchbvClZz8ZqtBwzz1bdOMSxnWEzF',
  911.             'orangedebiturl' => 'https://billpayment.api.prod.run.billmap.net/api/Bill/orange/webpayment',
  912.             'orangecode' => 'MYHELPPLACE_ORANGE',
  914.             'mtnkey' => '2CSLsG7IDYHmR8Wp',
  915.             'mtnsecret' => '3puc5vA7cySjUGoCkAJZ5nzIesMg0uWdLVsNchbvClZz8ZqtBwzz1bdOMSxnWEzF',
  916.             'mtndebiturl' => 'https://billpayment.api.prod.run.billmap.net/api/Bill/debit/openapi',
  917.             'mtncode' => 'MYHELPPLACE_MTNCI',
  919.             'moovkey' => 'GX7fNUtKpzbaZbrM',
  920.             'moovsecret' => '2OZpbuvcRCDNapJrsVkHTE6gqocNdeN1DxIQIlEpBZjbR6GuQaBYkbim05fDbK1i',
  921.             'moovdebiturl' =>'https://billpayment.api.prod.run.billmap.net/api/Bill/debit/moov',
  922.             'moovcode' => 'MYHELPPLACE_MOOVCI',
  923.             
  924.             'wavekey' => '2CSLsG7IDYHmR8Wp',
  925.             'wavesecret' => '3puc5vA7cySjUGoCkAJZ5nzIesMg0uWdLVsNchbvClZz8ZqtBwzz1bdOMSxnWEzF',
  926.             'wavedebiturl' => 'https://billpayment.api.prod.run.billmap.net/api/bill/wave/checkout',
  927.             'wavecode' => 'MYHELPPLACE_WAVE'
  928.         );
  930.         if('POST' == $request->getMethod()){
  932.             $formData = json_decode($request->getContent());
  934.             if($plateforme == 'web'){
  936.                 $operateurPaiement = $request->request->get('operateurPaiement');
  937.                 $numeroDeTelephone = $request->request->get('numeroDeTelephone');
  938.                 $indicatifPays = $request->request->get('indicatifPays');
  940.                 $montantTransaction = $this->montantFinalOffre($offreDevis);
  941.                 $otp = $request->request->get('otp');
  943.             }else{
  944.                 // mobile
  945.             
  946.                 $operateurPaiement = $formData->operateurPaiement;
  947.                 $numeroDeTelephone = $formData->numeroDeTelephone;
  948.                 $indicatifPays = $formData->indicatifPays;
  950.                 $montantTransaction = $this->montantFinalOffre($offreDevis);
  952.                 $otp = $formData->otp;
  954.             }
  956.             
  957.             $id_transaction = '';
  958.             if ($montantTransaction <= 0) {
  959.                 return $this->allowRemoteRequest(new JsonResponse([
  960.                     'error' => 'Montant de prestation invalide',
  961.                     'message' => 'Cette offre de devis ne possède pas de montant payable.',
  962.                 ], Response::HTTP_BAD_REQUEST));
  963.             }
  964.             
  966.                 $paiementService = new PaiementService;
  967.                 $paiementService->setMontant($montantTransaction);
  968.                 $paiementService->setUser($user);
  969.                 $paiementService->setTypeService('PRESTATION');
  970.                 $paiementService->setLaDate(new \DateTime());
  971.                 $paiementService->setOffreDevis($offreDevis);
  972.                 //transaction id
  973.                 
  974.                 // Payment description
  975.                 $description_du_paiement = "Devenir premium";
  976.                 // Payment Date must be on date format
  977.                 $date_transaction = date("Y-m-d H:i:s");
  978.                 // Amount
  979.                 $montant_a_payer = $montantTransaction;
  982.                 //$commande->setCpmTransId($id_transaction);
  983.                 //$commande->setCpmAmount($montant_a_payer);
  984.                 //$commande->setUser($user);
  985.                 $em->persist($paiementService);
  987.                 $em->flush();
  988.                 
  989.                 //Ici debute le paiement par Jeko
  990.                 $laReference = $paiementService->getId() . '@PRESTATION@' . $offreDevis->getId();
  991.                 // notify url
  992.                 $returnUrls = $this->getJekoReturnUrls($laReference, $plateforme);
  993.                 $successUrl = $returnUrls['successUrl'];
  994.                 // return url
  995.                 $errorUrl = $returnUrls['errorUrl'];
  996.                 
  998.                 $ch = curl_init($this->getJekoBaseUrl().'/payment_requests');
  999.                 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  1000.                 curl_setopt($ch, CURLOPT_POST, true);
  1001.                 curl_setopt($ch, CURLOPT_HTTPHEADER, [
  1002.                     'X-API-KEY:'. $this->getJekoAPI(),
  1003.                     'X-API-KEY-ID:'.$this->getJekoAPIID(),
  1004.                     'Content-Type: application/json'
  1005.                 ]);
  1007.                 $amountCents = (int) round($montantTransaction * 100);
  1008.                 
  1009.                 curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
  1010.                     'storeId' => $this->getJekoStoreId(),
  1011.                     'amountCents' => $amountCents,
  1012.                     'currency' => 'XOF',
  1013.                     'reference' =>$laReference,
  1014.                     'paymentDetails' => [
  1015.                         'type' => 'redirect',
  1016.                         'data' => [
  1017.                             'paymentMethod' => $operateurPaiement,
  1018.                             'successUrl' => $successUrl,
  1019.                             'errorUrl' => $errorUrl
  1020.                         ]
  1021.                     ]
  1022.                 ]));
  1024.                 
  1025.                 $response = curl_exec($ch);
  1026.                 $curlError = curl_error($ch);
  1027.                 $httpCode = (int)curl_getinfo($ch, CURLINFO_HTTP_CODE);
  1028.                 curl_close($ch);
  1029.                 $paymentRequest = json_decode($response, true);
  1031.                 if ($response === false || $curlError || !is_array($paymentRequest) || empty($paymentRequest['redirectUrl'])) {
  1032.                     $providerMessage = is_array($paymentRequest)
  1033.                         ? ($paymentRequest['message'] ?? $paymentRequest['error'] ?? 'Jèko n’a pas fourni de redirectUrl')
  1034.                         : 'Réponse Jèko invalide';
  1035.                     $providerResponse = is_array($paymentRequest) ? $paymentRequest : ['raw' => substr((string)$response, 0, 2000)];
  1036.                     $providerDetails = $providerResponse['extras'] ?? $providerResponse['errors'] ?? $providerResponse['errorReason'] ?? null;
  1037.                     if ($providerDetails !== null) {
  1038.                         $providerMessage .= ' - ' . (is_string($providerDetails) ? $providerDetails : json_encode($providerDetails));
  1039.                     }
  1040.                     return $this->allowRemoteRequest(new JsonResponse([
  1041.                         'error' => 'Unable to create Jèko payment',
  1042.                         'message' => $providerMessage,
  1043.                         'details' => $providerDetails,
  1044.                         'providerResponse' => $providerResponse,
  1045.                         'providerStatus' => $httpCode,
  1046.                     ], Response::HTTP_BAD_GATEWAY));
  1047.                 }
  1048.                 
  1049.                 $paiementService->setCpmTransId($paymentRequest['id'] ?? $id_transaction);
  1050.                 $em->flush();
  1051.                 if($plateforme == 'web'){
  1052.                     return $this->redirect($paymentRequest['redirectUrl']);
  1053.                 }else{
  1055.                     $data = array(
  1056.                             'error' => '',
  1057.                             'message' => '',
  1058.                             'redirectUrl' => $paymentRequest['redirectUrl'],
  1059.                             'successUrl' => $successUrl,
  1060.                             'errorUrl' => $errorUrl,
  1061.                             'reference' => $laReference,
  1062.                             'paymentReference' => $laReference
  1063.                             
  1064.                     );
  1065.                     
  1066.                     $response = new JsonResponse;
  1067.         
  1068.                     $response = $this->allowRemoteRequest($response);
  1069.                     
  1070.                     $response->setContent(json_encode($data));
  1071.                     return $response;
  1072.                 }
  1074.                 //là se termine le paiement par Jeko
  1075.                 $em->flush();
  1076.         }
  1077.         
  1078.         if($plateforme == 'mobile'){
  1079.             return $this->render('api/paiement_prestation.html.twig', [
  1080.                 
  1081.                 ]);
  1082.         }
  1084.         return $this->render('gestion/paiement_prestation.html.twig', [
  1085.             
  1086.         ]);    
  1088.         if($request->getMethod() == 'POST'){
  1089.             
  1091.             $formData = json_decode($request->getContent());
  1092.             
  1093.             $dateDebut = $formData->dateDebut;
  1094.             $dateDebut = new \DateTime($dateDebut);
  1095.             $dateDebut->setTime(0, 0);
  1096.             
  1098.             $dateFin = $formData->dateFin;
  1099.             //$dateFin = $request->request->get('dateFin');
  1100.             
  1101.             $dateFin = new \DateTime($dateFin);
  1102.             $dateFin->setTime(23, 59);
  1104.             $demandeRetraits = $em->getRepository(DemandeRetrait::class)
  1105.                                 ->demandeDUnePeriode($boutique->getId(), $dateDebut, $dateFin, true);
  1107.         }
  1109.         $data = array(
  1110.                 'error' => '',
  1111.                 'message' => '',
  1112.                 'demandeRetraits' => $demandeRetraits
  1113.                 
  1114.         );
  1115.         $response = new JsonResponse;
  1116.         
  1117.         $response = $this->allowRemoteRequest($response);
  1118.         
  1119.         $response->setContent(json_encode($data));
  1120.         return $response;
  1121.         
  1122.         return $this->render('api/envoyer_push_notification.html.twig', [ 
  1123.             
  1124.         ]);        
  1125.     }
  1127.     /**
  1128.      * @Route("/finaliser-abonnement/{slug}/{plan}", name="gestion_finaliser_abonnement")
  1129.      * @return \Symfony\Component\HttpFoundation\Response
  1130.      */
  1131.     public function finaliserAction(Request $request, Boutique $boutique, $plan)
  1132.     {
  1133.         $em = $this->getDoctrine()
  1134.                     ->getManager();
  1135.                     
  1136.         $user = $this->getUser();
  1137.         $userBoutique = $em->getRepository(UserBoutique::class)
  1138.                         ->findOneBy(
  1139.                             array(
  1140.                             'user' => $user->getId(),
  1141.                             'boutique' => $boutique->getId()
  1142.                             )
  1143.                         );
  1144.         $plan = $em->getRepository(Plan::class)
  1145.                         ->findOneBySlug($plan);
  1147.         return $this->render('gestion/finaliser_abonnement.html.twig', [
  1148.                 'user' => $user,
  1149.                 'boutique' => $boutique,
  1150.                 'userBoutique' => $userBoutique,
  1151.                 'plan' => $plan
  1152.             ]);
  1153.     }
  1155.     /**
  1156.     * @Route("/payment/billmap-return", name="gestion_billmap_return")
  1157.     */
  1158.     public function billmapReturnAction(Request $request)
  1159.     {
  1160.         $em = $this->getDoctrine()
  1161.                     ->getManager();
  1163.         $user = $this->getUser();
  1165.         /* 
  1166.         https://www.myhelpplace.com/fr/gestion/payment/billmap-return?
  1167.         // Reference=66&
  1168.         // Amount=100.00&
  1169.         // MSISDN=2250574053562&
  1170.         // NetworkMSISDN=2250574053562&
  1171.         // BillMapTransactionId=T4398121&
  1172.         // ExternalTransactionId=16464863303&
  1173.         // ResponseCode=01&
  1174.         // ResponseMessage=Successfully
  1175.         */
  1176.         $reference = $request->query->get('Reference'); //Ici, c'est bien la valeur qui avait été passé dans "metaData" lors de la requete 
  1177.         $montant = $request->query->get('Amount');
  1178.         $mois = $request->query->get('MetaData');
  1179.         $numeroDeTelephone = $request->query->get('MSISDN');
  1180.         $billMapTransactionId = $request->query->get('BillMapTransactionId');
  1181.         $responseMessage = $request->query->get('ResponseMessage');
  1182.         $responseCode = $request->query->get('ResponseCode');
  1183.         
  1185.         if($responseCode == '01'){
  1187.             $reference = explode('@', $reference); //'metaData' => ''.$paiementService->getId().'@SERVICE',
  1188.             if($reference[1] == 'ABONNEMENT'){
  1189.                 //Si la transaction a marché 
  1190.                 $commande = $em->getRepository(Commande::class)
  1191.                         ->findOneByCpmTransId($billMapTransactionId);
  1192.                 $dateFin  =  new \DateTime();
  1193.                 //
  1194.                 $dateFin->modify('+'.$mois .' month');
  1195.                 $commande->setDateFin($dateFin);
  1196.                 $em->flush();
  1197.             }
  1199.             if($reference[1] == 'SERVICE'){
  1200.                 //Si la transaction a marché 
  1201.                 $paiementService = $em->getRepository(PaiementService::class)
  1202.                         ->findOneByCpmTransId($billMapTransactionId);
  1203.                 $paiementService->setEtat('VALIDE');
  1204.                 
  1205.                 $em->flush();
  1206.             }
  1208.             if($reference[1] == 'PRESTATION'){
  1209.                 // Le lien paiement -> offre permet d'identifier le prestataire.
  1210.                 // La référence contient l'id du paiement, pas "PRESTATION".
  1211.                 $paiementService = $em->getRepository(PaiementService::class)
  1212.                         ->findOneById($reference[0]);
  1213.                 if ($paiementService) {
  1214.                     $previousStatus = $paiementService->getEtat();
  1215.                     $paiementService->setEtat('VALIDE');
  1216.                     $offreDevis = $paiementService->getOffreDevis();
  1217.                     $boutique = $offreDevis ? $offreDevis->getBoutique() : null;
  1218.                     if ($boutique && $previousStatus !== 'VALIDE') {
  1219.                         $boutique->setSolde((float) ($boutique->getSolde() ?? 0) + ((float) $paiementService->getMontant() * 90 / 100));
  1220.                     }
  1221.                     $paiementService->setCpmTransId($billMapTransactionId);
  1222.                     $em->flush();
  1223.                 }
  1224.             }
  1226.             
  1227.         }
  1228.         $response = new JsonResponse;
  1229.         $data = array(
  1230.             'mois' => 'Mois souscrit '. $mois,
  1231.             'montant' => 'Montant ' . $montant,
  1232.             'bonjour' => 'Bonjour tout le monde'
  1233.         );
  1235.         $response = $this->allowRemoteRequest($response);
  1236.         
  1237.         $response->setContent(json_encode($data));
  1238.         return $response;
  1242.         return $this->render('gestion/billmap_return.html.twig', [
  1243.             
  1244.             'user' => $user
  1245.         ]);
  1246.     }
  1248.     /**
  1249.      * Jèko is the source of truth for payment state. The return URLs only
  1250.      * notify the client that it can ask this backend for the current state.
  1251.      *
  1252.      * @Route("/payment/jeko-webhook", name="gestion_jeko_webhook", methods={"POST"})
  1253.      */
  1254.     public function jekoWebhookAction(Request $request)
  1255.     {
  1256.         $rawPayload = $request->getContent();
  1257.         $signature = $request->headers->get('Jeko-Signature');
  1258.         $secret = $this->getJekoWebhookSecret();
  1260.         if (!$secret || !$signature || !hash_equals(hash_hmac('sha256', $rawPayload, $secret), $signature)) {
  1261.             return new Response('Invalid webhook signature', Response::HTTP_UNAUTHORIZED);
  1262.         }
  1264.         $payload = json_decode($rawPayload, true);
  1265.         if (!is_array($payload)) {
  1266.             return new Response('Invalid webhook payload', Response::HTTP_BAD_REQUEST);
  1267.         }
  1268.         // Selon le produit/version Jèko, la référence peut être dans
  1269.         // transactionDetails ou directement à la racine du payload.
  1270.         $reference = $payload['transactionDetails']['reference'] ?? ($payload['reference'] ?? null);
  1271.         $rawStatus = strtolower((string)($payload['status'] ?? ''));
  1272.         $statusMap = [
  1273.             'success' => 'success',
  1274.             'completed' => 'success',
  1275.             'paid' => 'success',
  1276.             'pending' => 'pending',
  1277.             'processing' => 'pending',
  1278.             'error' => 'error',
  1279.             'failed' => 'error',
  1280.         ];
  1281.         $status = $statusMap[$rawStatus] ?? null;
  1283.         if (($payload['transactionType'] ?? null) !== 'PaymentRequest' || !$reference || $status === null) {
  1284.             return new Response('Invalid webhook payload', Response::HTTP_BAD_REQUEST);
  1285.         }
  1287.         $parts = explode('@', $reference);
  1288.         $paymentId = $parts[0] ?? null;
  1289.         $paymentType = $parts[1] ?? null;
  1290.         $em = $this->getDoctrine()->getManager();
  1292.         if ($paymentType === 'ABONNEMENT') {
  1293.             $commande = $em->getRepository(Commande::class)->findOneById($paymentId);
  1294.             if (!$commande) {
  1295.                 return new Response('Unknown payment reference', Response::HTTP_NOT_FOUND);
  1296.             }
  1298.             // Jèko may retry a webhook. Do not extend an abonnement twice.
  1299.             if ($commande->getCpmTransStatus() !== 'success' && $status === 'success') {
  1300.                 $months = (int)($parts[2] ?? 0);
  1301.                 $dateFin = new \DateTime();
  1302.                 $dateFin->modify('+' . $months . ' month');
  1303.                 $commande->setDateFin($dateFin);
  1304.             }
  1305.             $commande->setCpmTransStatus($status);
  1306.             $em->flush();
  1307.         } elseif (in_array($paymentType, ['SERVICE', 'DISCUSSION', 'DEVIS', 'PRESTATION'], true)) {
  1308.             $paiementService = $em->getRepository(PaiementService::class)->findOneById($paymentId);
  1309.             if (!$paiementService) {
  1310.                 return new Response('Unknown payment reference', Response::HTTP_NOT_FOUND);
  1311.             }
  1312.             $this->rattacherOffreDepuisReference($paiementService, $parts, $em);
  1314.             // Keep the status vocabulary already used by PaiementService.
  1315.             $previousStatus = $paiementService->getEtat();
  1316.             $paiementService->setEtat($status === 'success' ? 'VALIDE' : ($status === 'error' ? 'ECHEC' : 'EN ATTENTE'));
  1318.             // Credit the provider only once, after Jeko confirms the prestation payment.
  1319.             if ($paymentType === 'PRESTATION' && $status === 'success' && $previousStatus !== 'VALIDE') {
  1320.                 $offreDevis = $paiementService->getOffreDevis();
  1321.                 $boutique = $offreDevis ? $offreDevis->getBoutique() : null;
  1322.                 if ($boutique) {
  1323.                     $boutique->setSolde((float) ($boutique->getSolde() ?? 0) + ((float) $paiementService->getMontant() * 90 / 100));
  1324.                 }
  1325.             }
  1326.             $transactionDetails = is_array($payload['transactionDetails'] ?? null) ? $payload['transactionDetails'] : [];
  1327.             $transaction = is_array($payload['transaction'] ?? null) ? $payload['transaction'] : [];
  1328.             $transactionId = $transactionDetails['id']
  1329.                 ?? ($transaction['id'] ?? ($payload['transactionId'] ?? ($payload['id'] ?? $paiementService->getCpmTransId())));
  1330.             $paiementService->setCpmTransId((string)$transactionId);
  1331.             $em->flush();
  1332.             if ($paymentType === 'PRESTATION' && $status === 'success' && $previousStatus !== 'VALIDE') {
  1333.                 $this->notifierPaiementValide($paiementService);
  1334.             }
  1335.         } else {
  1336.             return new Response('Unknown payment reference', Response::HTTP_NOT_FOUND);
  1337.         }
  1339.         // Jèko considère uniquement HTTP 200 comme accusé de réception.
  1340.         return new Response('', Response::HTTP_OK);
  1341.     }
  1343.     /**
  1344.      * @Route("/payment/status/{reference}", name="gestion_payment_status", requirements={"reference"=".+"}, methods={"GET"})
  1345.      */
  1346.     public function paymentStatusAction(Request $request, $reference)
  1347.     {
  1348.         $user = $this->getUser();
  1349.         $reference = rawurldecode($reference);
  1351.         $parts = explode('@', $reference);
  1352.         $paymentId = $parts[0] ?? null;
  1353.         $paymentType = $parts[1] ?? null;
  1354.         $em = $this->getDoctrine()->getManager();
  1355.         $status = null;
  1356.         $owner = null;
  1357.         $payment = null;
  1359.         if ($paymentType === 'ABONNEMENT') {
  1360.             $payment = $em->getRepository(Commande::class)->findOneById($paymentId);
  1361.             if ($payment) {
  1362.                 $status = $payment->getCpmTransStatus();
  1363.                 $owner = $payment->getUser();
  1364.             }
  1365.         } elseif (in_array($paymentType, ['SERVICE', 'DISCUSSION', 'DEVIS', 'PRESTATION'], true)) {
  1366.             $payment = $em->getRepository(PaiementService::class)->findOneById($paymentId);
  1367.             if ($payment) {
  1368.                 $status = $payment->getEtat();
  1369.                 $owner = $payment->getUser();
  1370.                 $this->rattacherOffreDepuisReference($payment, $parts, $em);
  1371.             }
  1372.         }
  1374.         if (!$payment) {
  1375.             return new JsonResponse(['error' => 'Payment not found'], Response::HTTP_NOT_FOUND);
  1376.         }
  1378.         // Fallback recommandé par Jèko : si la webhook est retardée, confirmer
  1379.         // le statut directement auprès de l’API avec l’ID de la demande.
  1380.         $providerId = $payment instanceof Commande ? $payment->getCpmTransId() : $payment->getCpmTransId();
  1381.         if ($providerId && in_array($status, [null, 'EN ATTENTE'], true)) {
  1382.             $providerPayment = $this->getJekoPaymentRequest($providerId);
  1383.             $providerStatus = strtolower((string)($providerPayment['status'] ?? ''));
  1384.             $providerStatusMap = [
  1385.                 'success' => 'success',
  1386.                 'completed' => 'success',
  1387.                 'paid' => 'success',
  1388.                 'pending' => 'pending',
  1389.                 'processing' => 'pending',
  1390.                 'error' => 'error',
  1391.                 'failed' => 'error',
  1392.             ];
  1393.             $confirmedStatus = $providerStatusMap[$providerStatus] ?? null;
  1394.             if ($confirmedStatus !== null) {
  1395.                 $status = $confirmedStatus;
  1396.                 if ($paymentType === 'ABONNEMENT') {
  1397.                     $payment->setCpmTransStatus($confirmedStatus);
  1398.                     $months = (int)($parts[2] ?? 0);
  1399.                     if ($confirmedStatus === 'success' && $months > 0 && !$payment->getDateFin()) {
  1400.                         $dateFin = new \DateTime();
  1401.                         $dateFin->modify('+' . $months . ' month');
  1402.                         $payment->setDateFin($dateFin);
  1403.                     }
  1404.                 } else {
  1405.                     $previousStatus = $payment->getEtat();
  1406.                     $payment->setEtat($confirmedStatus === 'success' ? 'VALIDE' : ($confirmedStatus === 'error' ? 'ECHEC' : 'EN ATTENTE'));
  1407.                     if ($paymentType === 'PRESTATION' && $confirmedStatus === 'success' && $previousStatus !== 'VALIDE') {
  1408.                         $offreDevis = $payment->getOffreDevis();
  1409.                         $boutique = $offreDevis ? $offreDevis->getBoutique() : null;
  1410.                         if ($boutique) {
  1411.                             $boutique->setSolde((float) ($boutique->getSolde() ?? 0) + ((float) $payment->getMontant() * 90 / 100));
  1412.                         }
  1413.                     }
  1414.                     $payment->setCpmTransId($providerId);
  1415.                 }
  1416.                 $em->flush();
  1417.                 if ($paymentType === 'PRESTATION' && $confirmedStatus === 'success' && $previousStatus !== 'VALIDE') {
  1418.                     $this->notifierPaiementValide($payment);
  1419.                 }
  1420.             }
  1421.         }
  1423.         // Le mobile consulte le statut après le retour Jèko et ne possède pas
  1424.         // forcément une session Symfony. Une session connectée reste contrôlée.
  1425.         if ($user && $owner && $owner->getId() !== $user->getId()) {
  1426.             return new JsonResponse(['error' => 'Payment not found'], Response::HTTP_NOT_FOUND);
  1427.         }
  1429.         $jekoStatus = $status;
  1430.         if ($status === 'VALIDE') {
  1431.             $jekoStatus = 'success';
  1432.         } elseif ($status === 'ECHEC') {
  1433.             $jekoStatus = 'error';
  1434.         } elseif ($status === 'EN ATTENTE') {
  1435.             $jekoStatus = 'pending';
  1436.         }
  1438.         $response = new JsonResponse([
  1439.             'reference' => $reference,
  1440.             'paymentReference' => $reference,
  1441.             'status' => $status,
  1442.             'localStatus' => $status,
  1443.             'jekoStatus' => $jekoStatus,
  1444.             'success' => $jekoStatus === 'success',
  1445.         ]);
  1446.         return $this->allowRemoteRequest($response);
  1447.     }
  1449.     /**
  1450.      * Enregistre les notifications après confirmation Jèko. Le subscriber
  1451.      * Doctrine se charge ensuite de l'envoi push Firebase.
  1452.      * Cette méthode n'est appelée que lors du passage vers VALIDE, donc les
  1453.      * webhooks répétés ne créent pas de doublons.
  1454.      */
  1455.     private function rattacherOffreDepuisReference(PaiementService $paiement, array $parts, $em): void
  1456.     {
  1457.         if ($paiement->getOffreDevis() || empty($parts[2]) || !ctype_digit((string) $parts[2])) {
  1458.             return;
  1459.         }
  1461.         $offreDevis = $em->getRepository(OffreDevis::class)->findOneById((int) $parts[2]);
  1462.         if ($offreDevis && $offreDevis->getBoutique()) {
  1463.             $paiement->setOffreDevis($offreDevis);
  1464.             $em->persist($paiement);
  1465.             $em->flush();
  1466.         }
  1467.     }
  1469.     private function notifierPaiementValide(PaiementService $paiement): void
  1470.     {
  1471.         $offreDevis = $paiement->getOffreDevis();
  1472.         $prestataire = $offreDevis ? $offreDevis->getUser() : null;
  1473.         // Certaines anciennes offres n'ont pas de user renseigné alors que la
  1474.         // boutique possède bien un propriétaire dans UserBoutique. Dans ce cas,
  1475.         // la notification doit quand même parvenir au prestataire.
  1476.         if (!$prestataire && $offreDevis && $offreDevis->getBoutique()) {
  1477.             $prestataire = $this->getDoctrine()->getManager()
  1478.                 ->getRepository(UserBoutique::class)
  1479.                 ->findOneBy(['boutique' => $offreDevis->getBoutique()]);
  1480.             $prestataire = $prestataire ? $prestataire->getUser() : null;
  1481.         }
  1482.         $client = $paiement->getUser();
  1483.         $destinataires = [];
  1485.         if ($prestataire) {
  1486.             $destinataires[$prestataire->getId()] = [
  1487.                 'user' => $prestataire,
  1488.                 'title' => 'Paiement reçu',
  1489.                 'body' => 'Le paiement de votre prestation a été confirmé.',
  1490.             ];
  1491.         }
  1492.         if ($client && !isset($destinataires[$client->getId()])) {
  1493.             $destinataires[$client->getId()] = [
  1494.                 'user' => $client,
  1495.                 'title' => 'Paiement confirmé',
  1496.                 'body' => 'Votre paiement de ' . (float) $paiement->getMontant() . ' XOF a été confirmé.',
  1497.             ];
  1498.         }
  1500.         $em = $this->getDoctrine()->getManager();
  1501.         foreach ($destinataires as $destinataire) {
  1502.             $notification = new Notification();
  1503.             $notification->setUser($destinataire['user']);
  1504.             $notification->setTypeNotification('paiement');
  1505.             $notification->setDescription($destinataire['body']);
  1506.             $notification->setExtraData((string) $paiement->getId());
  1507.             $notification->setLien('');
  1508.             $em->persist($notification);
  1509.         }
  1510.         $em->flush();
  1512.     }
  1514.     private function montantFinalOffre(OffreDevis $offreDevis): float
  1515.     {
  1516.         $valeurFinanciere = $offreDevis->getValeurFinanciere();
  1517.         if ($valeurFinanciere !== null && (float) $valeurFinanciere > 0) {
  1518.             return (float) $valeurFinanciere;
  1519.         }
  1521.         $contreProposition = $offreDevis->getContrePropositionFinanciere();
  1522.         if ($contreProposition !== null && (float) $contreProposition > 0) {
  1523.             return (float) $contreProposition;
  1524.         }
  1526.         // Les anciennes demandes directes vers une boutique créaient une offre
  1527.         // sans montant propre, alors que leur devis possède un budget fixe.
  1528.         // Ce fallback est volontairement limité au cas min == max afin de ne
  1529.         // jamais transformer une fourchette budgétaire en montant payable.
  1530.         $devis = $offreDevis->getDevis();
  1531.         if ($devis) {
  1532.             $budgetMin = is_numeric($devis->getBudgetMin()) ? (float) $devis->getBudgetMin() : 0.0;
  1533.             $budgetMax = is_numeric($devis->getBudgetMax()) ? (float) $devis->getBudgetMax() : 0.0;
  1534.             if ($budgetMin > 0 && $budgetMin === $budgetMax) {
  1535.                 return $budgetMin;
  1536.             }
  1537.         }
  1539.         return 0.0;
  1540.     }
  1542.     /**
  1543.      * Retourne vrai si un paiement de frais non échoué existe déjà aujourd'hui.
  1544.      * Les paiements échoués restent retentables ; les paiements en attente ou
  1545.      * validés réservent le droit quotidien.
  1546.      */
  1547.     private function paiementFraisDuJourExiste($em, AppUser $user, string $paymentType): bool
  1548.     {
  1549.         $debut = new \DateTime('today');
  1550.         $fin = (clone $debut)->modify('+1 day');
  1552.         $paiement = $em->getRepository(PaiementService::class)
  1553.             ->createQueryBuilder('p')
  1554.             ->where('p.user = :user')
  1555.             ->andWhere('p.typeService = :typeService')
  1556.             ->andWhere('p.laDate >= :debut')
  1557.             ->andWhere('p.laDate < :fin')
  1558.             ->andWhere('p.etat IN (:etats)')
  1559.             ->setParameter('user', $user)
  1560.             ->setParameter('typeService', $paymentType)
  1561.             ->setParameter('debut', $debut)
  1562.             ->setParameter('fin', $fin)
  1563.             ->setParameter('etats', ['EN ATTENTE', 'VALIDE'])
  1564.             ->setMaxResults(1)
  1565.             ->getQuery()
  1566.             ->getOneOrNullResult();
  1568.         return $paiement !== null;
  1569.     }
  1571.     private function getJekoPaymentRequest($paymentRequestId)
  1572.     {
  1573.         $ch = curl_init($this->getJekoBaseUrl() . '/payment_requests/' . rawurlencode($paymentRequestId));
  1574.         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  1575.         curl_setopt($ch, CURLOPT_HTTPHEADER, [
  1576.             'X-API-KEY:' . $this->getJekoAPI(),
  1577.             'X-API-KEY-ID:' . $this->getJekoAPIID(),
  1578.         ]);
  1579.         curl_setopt($ch, CURLOPT_TIMEOUT, 5);
  1580.         $body = curl_exec($ch);
  1581.         $httpCode = (int)curl_getinfo($ch, CURLINFO_HTTP_CODE);
  1582.         curl_close($ch);
  1584.         if ($body === false || $httpCode < 200 || $httpCode >= 300) {
  1585.             return null;
  1586.         }
  1588.         $data = json_decode($body, true);
  1589.         return is_array($data) ? $data : null;
  1590.     }
  1592.     private function getJekoReturnUrls($reference, $plateforme)
  1593.     {
  1594.         if ($plateforme === 'mobile') {
  1595.             return [
  1596.                 // Jèko exige une URL HTTP(S) valide dans la requête. Ces routes
  1597.                 // redirigeront ensuite vers le deep link de l’application mobile.
  1598.                 'successUrl' => $this->generateUrl('gestion_payment_success', ['transaction' => $reference, 'plateforme' => 'mobile'], UrlGeneratorInterface::ABSOLUTE_URL),
  1599.                 'errorUrl' => $this->generateUrl('gestion_payment_error', ['transaction' => $reference, 'plateforme' => 'mobile'], UrlGeneratorInterface::ABSOLUTE_URL),
  1600.             ];
  1601.         }
  1603.         return [
  1604.             'successUrl' => $this->generateUrl('gestion_payment_success', ['transaction' => $reference, 'plateforme' => 'web'], UrlGeneratorInterface::ABSOLUTE_URL),
  1605.             'errorUrl' => $this->generateUrl('gestion_payment_error', ['transaction' => $reference, 'plateforme' => 'web'], UrlGeneratorInterface::ABSOLUTE_URL),
  1606.         ];
  1607.     }
  1609.     private function getJekoWebhookSecret()
  1610.     {
  1611.         return $_ENV['JEKO_WEBHOOK_SECRET'] ?? getenv('JEKO_WEBHOOK_SECRET') ?: null;
  1612.     }
  1614.     /**
  1615.     * @Route("/payment/success/{transaction}/{plateforme}", name="gestion_payment_success")
  1616.     */
  1617.     public function paymentSuccessAction(Request $request, $transaction, $plateforme)
  1618.     {
  1619.         $user = $this->getUser();
  1620.         if($plateforme == 'web'){
  1621.             return $this->render('entreprise/payment_success.html.twig', ['user' => $user]);
  1622.         }else{
  1623.             return new RedirectResponse('helpplace://payment/success?reference=' . rawurlencode($transaction));
  1624.         }
  1625.         
  1629.         return new Response('', Response::HTTP_NO_CONTENT);
  1630.     }
  1631.     
  1632.     /**
  1633.     * @Route("/payment/error/{transaction}/{plateforme}", name="gestion_payment_error")
  1634.      */
  1635.     public function paymentErrorAction(Request $request, $transaction, $plateforme)
  1636.     {
  1637.         if($plateforme == 'web'){
  1638.             return $this->render('entreprise/payment_error.html.twig', []);
  1639.         }else{
  1640.             return new RedirectResponse('helpplace://payment/error?reference=' . rawurlencode($transaction));
  1641.         }
  1642.         
  1643.         
  1644.         
  1645.         return new Response('', Response::HTTP_NO_CONTENT);
  1646.     }
  1647.     
  1648.     /**
  1649.     * @Route("/payment/cancel/{transaction}", name="gestion_payment_cancel")
  1650.      */
  1651.     public function paymentCancelction($transaction)
  1652.     {
  1653.         $em = $this->getDoctrine()
  1654.                     ->getManager();
  1655.         $user = $this->getUser();
  1656.         
  1657.         $requestStack = $this->get('request_stack');
  1658.         $request = $requestStack->getCurrentRequest();
  1659.         $ok_submission = '';
  1660.         $error = '';
  1661.         
  1662.         $commande = $em->getRePository(Commande::class)
  1663.                             ->findOneByCpmTransId($transaction);
  1664.                             
  1665.         $messageRequete = '';        
  1666.         
  1667.         
  1668.         if('POST' == $request->getMethod()){
  1669.             var_dump($_POST);
  1670.         }
  1671.         return $this->render('gestion/cinetpay_cancel.html.twig', [
  1672.             
  1673.             'user' => $user
  1674.         ]);
  1675.     }
  1676.     
  1677.         /**
  1678.      * @Route("/shop/{slug}/mini-statistic", name="gestion.mini_statistic")
  1679.      * @return \Symfony\Component\HttpFoundation\Response
  1680.      */
  1681.     public function miniStatisticAction(Request $request, Boutique $boutique)
  1682.     {
  1683.         $em = $this->getDoctrine()
  1684.                     ->getManager();
  1685.         
  1686.         $user = $this->getUser();
  1687.               
  1688.         
  1689.         $mois = date('mY');
  1690.         $annee = date('Y');
  1691.         
  1692.         $nombreOffreDevis = $em->getRepository(OffreDevis::class)
  1693.                         ->nombreOffreDevis($boutique->getId());
  1694.         
  1695.         $conversations = $em->getRepository(Conversation::class)
  1696.                         ->nombreMessageDUneBoutique($boutique->getId());    
  1697.             
  1698.         $nombreTiers = 0;
  1699.         
  1700.         $userBoutique = $em->getRepository(UserBoutique::class)
  1701.                         ->findOneBy(
  1702.                             array(
  1703.                             'user' => $user->getId(),
  1704.                             'boutique' => $boutique->getId()
  1705.                             )
  1706.                         );
  1707.                         
  1708.         return $this->render('gestion/mini_statistic.html.twig', [
  1709.            'boutique' => $boutique,
  1710.            'userBoutique' => $userBoutique,
  1711.            'nombreOffreDevis' => $nombreOffreDevis,
  1712.            'conversations' => $conversations
  1713.         ]);
  1714.     }
  1715.     
  1716.     
  1717.         
  1718.     /**
  1719.      * @Route("/{slug}/settings", name="gestion.settings")
  1720.      * @return \Symfony\Component\HttpFoundation\Response
  1721.      */
  1722.     public function settingsAction(Request $request, Boutique $boutique)
  1723.     {
  1724.         $em = $this->getDoctrine()
  1725.                     ->getManager();
  1726.         $user = $this->getUser();        
  1727.         $userBoutique = $em->getRepository(UserBoutique::class)
  1728.                         ->findOneBy(
  1729.                             array(
  1730.                             'user' => $user->getId(),
  1731.                             'boutique' => $boutique->getId()
  1732.                             )
  1733.                         );
  1734.         $form = $this->createForm(SettingBoutiqueOngletEntrepriseType::class, $boutique);
  1735.         $aUnAbonnementPayant = false;
  1736.         $commande = $em->getRepository(Commande::class)
  1737.                     ->findOneBy(
  1738.                         array(
  1739.                             'boutique' => $boutique
  1740.                         ),
  1741.                         array(
  1742.                             'dateFin' => 'DESC'
  1743.                         )
  1744.                     );
  1745.         if($commande != null){
  1746.             $aujourdhui = new \DateTime();
  1747.             if($commande->getDateFin() > $aujourdhui){
  1748.                 $aUnAbonnementPayant = true;
  1749.             }
  1750.         }
  1751.         if($request->getMethod() == 'POST'){
  1752.                $form->handleRequest($request);
  1753.                if($form->isValid()){
  1754.                    $em->flush();
  1755.                 } else {
  1756.                     $error =" Veillez corrigez vos erreurs";
  1757.                 }
  1758.         }
  1759.         return $this->render('gestion/settings.html.twig', [
  1760.            'boutique' => $boutique,
  1761.             'form' => $form->createView(),
  1762.             'userBoutique' => $userBoutique,
  1763.             'aUnAbonnementPayant' => $aUnAbonnementPayant
  1764.         ]);
  1765.     }
  1766.     
  1767.     
  1768.     /**
  1769.      * @Route("/{slug}/edit-entreprise", name="gestion.edit_entreprise")
  1770.      * @return \Symfony\Component\HttpFoundation\Response
  1771.      */
  1772.     public function editEntrepriseAction(Request $request, Boutique $boutique)
  1773.     {
  1774.         $em = $this->getDoctrine()
  1775.                     ->getManager();
  1776.         $user = $this->getUser();        
  1777.         $userBoutique = $em->getRepository(UserBoutique::class)
  1778.                         ->findOneBy(
  1779.                             array(
  1780.                             'user' => $user->getId(),
  1781.                             'boutique' => $boutique->getId()
  1782.                             )
  1783.                         );    
  1784.         $form = $this->createForm(SettingBoutiqueOngletEntrepriseType::class, $boutique);
  1785.         $aUnAbonnementPayant = false;
  1786.         $commande = $em->getRepository(Commande::class)
  1787.                     ->findOneBy(
  1788.                         array(
  1789.                             'boutique' => $boutique
  1790.                         ),
  1791.                         array(
  1792.                             'dateFin' => 'DESC'
  1793.                         )
  1794.                     );
  1795.         if($commande != null){
  1796.             $aujourdhui = new \DateTime();
  1797.             if($commande->getDateFin() >= $aujourdhui){
  1798.                 $aUnAbonnementPayant = true;
  1799.             }
  1800.         }
  1801.         if($request->getMethod() == 'POST'){
  1802.                $form->handleRequest($request);
  1803.                if($form->isValid()){
  1804.                   
  1805.                    if(isset($_FILES['logo']) && $_FILES['logo']['error'] == 0 ){
  1806.                        $this->gererFichierMultipleLogo($boutique, $_FILES['logo']);
  1807.                       
  1808.                    }
  1809.                    $em->flush();
  1810.                 } else {
  1811.                     $error =" Veillez corrigez vos erreurs";
  1812.                 }
  1813.         }
  1814.         return $this->render('gestion/edit_entreprise.html.twig', [
  1815.            'boutique' => $boutique,
  1816.             'form' => $form->createView(),
  1817.             'userBoutique' => $userBoutique,
  1818.             'aUnAbonnementPayant' => $aUnAbonnementPayant
  1819.         ]);
  1820.     }
  1821.     
  1822.     /**
  1823.     * @Route("/{slug}/products", name="gestion.products")
  1824.      */
  1825.     public function productsAction(Boutique $boutique)
  1826.     {
  1827.         $em = $this->getDoctrine()
  1828.                     ->getManager();
  1829.                     
  1830.         $products = $em->getRePository(Produit::class)
  1831.                             ->findByBoutique($boutique);
  1832.          
  1833.          return $this->render('gestion/products.html.twig', [
  1834.             'products' => $products,
  1835.             'boutique' => $boutique
  1836.         ]);
  1837.     }
  1838.     
  1839.     /**
  1840.      * @Route("/{slug}/new-product", name="gestion.new_product")
  1841.      */
  1842.     public function newProductAction(Boutique $boutique)
  1843.     {
  1844.         $requestStack = $this->get('request_stack');
  1846.         $request = $requestStack->getCurrentRequest();
  1847.     
  1848.         $em = $this->getDoctrine()
  1849.                     ->getManager();
  1850.         $ok_submission = '';
  1851.         $error = '';        
  1852.         $produit = new Produit;
  1853.         $form = $this->createForm(ProduitType::class, $produit);
  1854.         $user = $this->getUser();
  1855.         
  1856.                             
  1857.         if('POST' == $request->getMethod() )
  1858.         {
  1859.             $form->handleRequest($request);
  1860.             if( $form->isValid()){
  1861.                 $produit->setBoutique($boutique);
  1862.                 if(isset($_FILES['imagePrincipale']) && $_FILES['imagePrincipale']['error'] == 0){
  1863.                     //var_dump($_FILES['fichier']);
  1864.                     
  1865.                     $em->persist($produit);
  1866.                     $em->flush();
  1867.                     
  1868.                     $this->gererFichierMultiple($produit, $_FILES['imagePrincipale'], true);
  1869.                     
  1870.                     $ok_submission = 'Enregistrement effectué';
  1871.     
  1872.                 } else{
  1873.                     $error = 'Veuillez indiquer l\'image principale';
  1874.                 }
  1875.                 
  1876.                 
  1877.                 if(isset($_FILES['photos']) && $_FILES['photos']['name'][0] != ''){
  1878.                         
  1879.                         $this->gererFichierMultiple($produit, $_FILES['photos']);
  1880.                 }
  1881.                 $produit = new Produit;
  1882.                 $form = $this->createForm(ProduitType::class, $produit);
  1883.                 
  1884.                 
  1885.             } else {
  1886.                 $form->getErrors(true, false); 
  1887.                 $error = 'Une erreur s\'est produite';
  1888.             }
  1889.         }
  1890.         return $this->render('gestion/new_product.html.twig', [
  1891.             'form' => $form->createView(),
  1892.             'error' => $error,
  1893.             'ok_submission' => $ok_submission,
  1894.             'boutique' => $boutique
  1895.         ]);
  1896.     }
  1897.     
  1898.     /**
  1899.      * @Route("/edit-main-image/{id}", name="gestion.edit_main_image")
  1900.      */
  1901.     public function editMainImageAction(Produit $produit)
  1902.     {
  1903.         $requestStack = $this->get('request_stack');
  1905.         $request = $requestStack->getCurrentRequest();
  1906.     
  1907.         $em = $this->getDoctrine()
  1908.                     ->getManager();
  1909.         $ok_submission = '';
  1910.         $error = '';        
  1911.         $user = $this->getUser();
  1912.         if('POST' == $request->getMethod()){
  1913.             $image = $produit->getImagePrincipale();
  1914.             if(isset($_FILES['imagePrincipale']) && $_FILES['imagePrincipale']['error'] == 0){
  1915.                 $data = $_FILES['imagePrincipale'];
  1916.                 $ex = pathinfo($data['name'])['extension'];
  1917.                 $exA = array('jpg', 'jpeg', 'png', 'gif');
  1918.                 
  1919.                 if (in_array(strtolower($ex), $exA)){
  1920.                 
  1921.                     $image->setExtension($ex);
  1922.                 } else {
  1923.                     throw new \RuntimeException('Désolé, vous n\'avez pas le droit de télécharger ce type de fichier: '.$ex);
  1924.                 }
  1925.                 
  1926.                 $name = $produit->getId().time().'.'.$ex;
  1927.                 //Delete old image
  1928.                 
  1929.                     unlink($image->getUploadRootDir().'/original/'.$image->getUrl());
  1930.                     if(!is_dir($image->getUploadRootDir().'/original/') && !mkdir($image->getUploadRootDir().'/original', 0777, true))
  1931.                     {
  1932.                         throw new \RuntimeException('Impossible de créer le dossier de destination');
  1933.                     }
  1934.                     
  1935.                     if (!move_uploaded_file($data['tmp_name'], $image->getUploadRootDir().'/original/'.$name))
  1936.                     {
  1937.                         throw new \RuntimeException('Désolé, une erreur s\'est produite.');
  1938.                     }
  1939.                     $image->setUrl($name);
  1940.                 } else{
  1941.                     $error = 'Veuillez indiquer l\'image principale';
  1942.                 }
  1943.             
  1944.             $ok_submission = 'Enregistrement effectué';
  1945.             $em->flush();
  1946.         }
  1947.         
  1948.         return $this->render('gestion/edit_main_image.html.twig', [
  1949.             'produit' => $produit,
  1950.             'error' => $error,
  1951.             'ok_submission' => $ok_submission
  1952.         ]);
  1953.     }
  1954.     
  1955.     
  1956.     
  1957.     /**
  1958.      * @Route("/delete-prodcut-image/{id}/{photo}", name="gestion.delete_product_image")
  1959.      */
  1960.     public function deleteProductImageAction(Produit $produit, $photo)
  1961.     {
  1962.         
  1963.         $em = $this->getDoctrine()
  1964.                     ->getManager();
  1965.         $photo = $em->getRePository(ProductPhoto::class)
  1966.                     ->findOneById($photo);
  1967.         $em->remove($photo);    
  1968.         $link = substr($photo->getUrl(), 32); //taille de https://www.lika.ci/uploads/img/
  1969.         
  1970.         unlink($photo->getUploadRootDir().'/'.$link);
  1971.         $em->flush();    
  1972.             
  1973.         return $this->redirectToRoute('gestion.products', array('slug' => $produit->getBoutique()->getSlug()));
  1974.                     
  1975.         
  1976.     }
  1977.     
  1978.     /**
  1979.      * @Route("/{slug}/add-more-image/{id}", name="gestion.add_more_image")
  1980.      */
  1981.     public function addMoreImageAction(Request $request,  $slug,  $id)
  1982.     {
  1983.         
  1984.         $em = $this->getDoctrine()
  1985.                     ->getManager();
  1986.         $boutique = $em->getRepository(Boutique::class)
  1987.                         ->findOneBySlug($slug);
  1988.         $produit = $em->getRepository(Produit::class)
  1989.                         ->findOneById($id);
  1990.         $ok_submission = '';
  1991.         $error = '';        
  1992.         $user = $this->getUser();
  1993.         
  1994.         if('POST' == $request->getMethod() )
  1995.         {
  1996.             if(isset($_FILES['photos'])){
  1997.                 $this->gererFichierMultiple($produit, $_FILES['photos']);
  1998.                 $ok_submission = 'Enregistrement effectué';
  1999.             }
  2000.             
  2001.         }
  2002.         
  2003.         return $this->render('gestion/add_more_image.html.twig', [
  2004.             'produit' => $produit,
  2005.             'error' => $error,
  2006.             'ok_submission' => $ok_submission,
  2007.             'boutique' => $boutique
  2008.         ]);
  2009.     }
  2010.     
  2011.     
  2012.     /**
  2013.      * @Route("/edit-product/{boutique}/{produit}", name="gestion.edit_product")
  2014.      */
  2015.     public function editProductAction($boutique, $produit)
  2016.     {
  2017.         $requestStack = $this->get('request_stack');
  2019.         $request = $requestStack->getCurrentRequest();
  2020.     
  2021.         $em = $this->getDoctrine()
  2022.                     ->getManager();
  2023.         $boutique = $em->getRepository(Boutique::class)
  2024.                         ->findOneById($boutique);
  2025.         
  2026.         $produit = $em->getRepository(Produit::class)
  2027.                         ->findOneById($produit);
  2028.         $ok_submission = '';
  2029.         $error = '';        
  2030.         $form = $this->createForm(ProduitEditType::class, $produit);
  2031.         $user = $this->getUser();
  2032.         if('POST' == $request->getMethod())
  2033.         {
  2034.             $form->handleRequest($request);
  2035.             if( $form->isValid()){
  2036.                 $em->flush();
  2037.                 $ok_submission = 'Enregistrement effectué';
  2038.                 if(isset($_FILES['imagePrincipale']) && $_FILES['imagePrincipale']['error'] == 0){
  2039.                     //var_dump($_FILES['fichier']);
  2040.                     
  2041.                     $em->persist($produit);
  2042.                     $em->flush();
  2043.                     
  2044.                     $this->gererFichierMultiple($produit, $_FILES['imagePrincipale'], true);
  2045.                     
  2046.                     $ok_submission = 'Enregistrement effectué';
  2047.     
  2048.                 } 
  2049.                 
  2050.                 if(isset($_FILES['photos']) && $_FILES['photos']['name'][0] != ''){
  2051.                         
  2052.                         $this->gererFichierMultiple($produit, $_FILES['photos']);
  2053.                 }
  2054.             } else {
  2055.                 $error = 'Une erreur s\'est produite';
  2056.             }
  2057.         }
  2058.         return $this->render('gestion/edit_product.html.twig', [
  2059.             'form' => $form->createView(),
  2060.             'error' => $error,
  2061.             'ok_submission' => $ok_submission,
  2062.             'boutique' => $boutique
  2063.         ]);
  2064.     }        
  2065.     
  2066.     //Produit/Service
  2067.     /**
  2068.      * @Route("/{slug}/delete-product/{id}", name="gestion.delete_product")
  2069.      * @return \Symfony\Component\HttpFoundation\Response
  2070.      */
  2071.     public function deleteProductAction(Request $request,  $slug, $id)
  2072.     { 
  2073.         $em = $this->getDoctrine()
  2074.                     ->getManager();
  2075.         $boutique = $em->getRepository(Boutique::class)
  2076.                         ->findOneBySlug($slug);
  2077.         
  2078.         $product = $em->getRepository(Produit::class)
  2079.                         ->findOneBy(
  2080.                         array(
  2081.                             'boutique' => $boutique->getId(),
  2082.                             'id' => $id
  2083.                         )
  2084.                         );
  2085.         if(null !== $product){
  2086.             //les auttres images
  2087.             foreach($product->getPhotos() as $photo){
  2088.                 $link = substr($photo->getUrl(), 32); //taille de https://www.lika.ci/uploads/img/
  2089.                 unlink($photo->getUploadRootDir().'/'.$link);
  2090.                 $em->remove($photo);
  2091.             }
  2092.             $em->flush();
  2093.             $em->remove($product);
  2094.             //Image principale
  2095.             if($product->getImagePrincipale() != null){
  2096.                 $link = substr($product->getImagePrincipale()->getUrl(), 32); //taille de https://www.lika.ci/uploads/img/
  2097.                 unlink($product->getImagePrincipale()->getUploadRootDir().'/'.$link);
  2098.                 
  2099.                 $em->remove($product->getImagePrincipale());
  2100.             }
  2101.             
  2102.         
  2103.             $em->flush();
  2104.         }
  2105.         return $this->redirectToRoute('gestion.products', array('slug' => $boutique->getSlug()));
  2106.     
  2107.     }
  2108.     
  2109.     
  2110.     /**
  2111.      * @Route("/{slug}/proposals", name="gestion.proposals")
  2112.      * @return \Symfony\Component\HttpFoundation\Response
  2113.      */
  2114.     public function proposalsAction(Request $request, Boutique $boutique)
  2115.     {
  2116.               
  2117.         $em = $this->getDoctrine()
  2118.                     ->getManager();
  2119.         
  2120.         $offreDevis = $em->getRepository(OffreDevis::class)
  2121.                         ->findByBoutique($boutique);
  2122.                         
  2123.         $devis = $em->getRepository(Devis::class)
  2124.                         ->findByCategorieEntreprise($boutique->getCategorieEntreprise());
  2125.         
  2126.         $user = $this->getUser();
  2127.         $notifications = $em->getRepository(Notification::class)
  2128.                                         ->findBy(
  2129.                                             array(
  2130.                                             'user' => $user,
  2131.                                             'vu'  => false,
  2132.                                             'typeNotification' => 'devis'
  2133.                                             )
  2134.                                         );
  2135.         foreach($notifications as $notification){
  2136.             $notification->setVu(true);
  2137.         }
  2138.         $em->flush();
  2139.         
  2140.         return $this->render('gestion/proposals.html.twig', [
  2141.            'offreDevis' => $offreDevis,
  2142.            'devis' => $devis,
  2143.            'boutique' => $boutique
  2144.         ]);
  2145.         
  2146.     }
  2147.     
  2148.     /**
  2149.      * @Route("/{slug}/my-tickets", name="gestion.my_tickets")
  2150.      */
  2151.     public function ticketsAction(Boutique $boutique)
  2152.     {
  2153.         $em = $this->getDoctrine()->getManager();
  2154.         
  2155.         $tickets = $em->getRepository(Ticket::class)
  2156.                         ->findByBoutique($boutique);
  2157.     
  2158.           return $this->render('gestion/tickets.html.twig', [
  2159.           'tickets' => $tickets,
  2160.           'boutique' => $boutique
  2161.         ]);
  2162.         
  2163.     }
  2164.     
  2165.     /**
  2166.      * @Route("/{slug}/new-ticket", name="gestion.new_ticket")
  2167.      * @return \Symfony\Component\HttpFoundation\Response
  2168.      */
  2169.     public function newTicketAction(Request $request, $slug)
  2170.     {
  2171.         $em = $this->getDoctrine()
  2172.                     ->getManager();
  2173.                     
  2174.         $boutique = $em->getRepository(Boutique::class)
  2175.                         ->findOneBySlug($slug);
  2176.         $user = $this->getUser();
  2177.         
  2178.         $ticket = new Ticket;
  2179.         
  2180.         $user = $this->getUser();
  2181.         $userBoutique = $em->getRepository(UserBoutique::class)
  2182.                         ->findOneBy(
  2183.                             array(
  2184.                             'user' => $user->getId(),
  2185.                             'boutique' => $boutique->getId()
  2186.                             )
  2187.                         );
  2188.         $form = $this->createForm(TicketType::class, $ticket);
  2189.         
  2190.         $ok_soumission = '';
  2191.         $error = '';
  2192.         
  2193.         if($request->getMethod() == 'POST'){
  2194.             
  2195.                $form->handleRequest($request);
  2196.                if($form->isValid()){
  2197.                    $ticket->setBoutique($boutique);
  2198.                    $ticket->setUser($user);
  2199.                    
  2200.                   $em->persist($ticket);
  2201.                   $em->flush();
  2202.                   
  2203.                 return $this->redirectToRoute('gestion.display_ticket', array('slug' => $boutique->getSlug(), 'id' => $ticket->getId()));
  2204.                 $ok_soumission =" Votre message a été pris en compte";
  2205.                     
  2206.                 $ticket = new Ticket;
  2207.                 
  2208.                 $form = $this->createForm(TicketType::class, $ticket);
  2209.                     
  2210.                 } else {
  2211.                     $error =" Veillez corrigez vos erreurs";
  2212.                 }
  2213.         }
  2214.         
  2215.         return $this->render('gestion/new_ticket.html.twig', [
  2216.            'boutique' => $boutique,
  2217.            'form' => $form->createView(),
  2218.            'userBoutique' => $userBoutique
  2219.         ]);
  2220.     }
  2221.     
  2222.     /**
  2223.      * @Route("/{slug}/display-ticket/{id}", name="gestion.display_ticket")
  2224.      * @return \Symfony\Component\HttpFoundation\Response
  2225.      */
  2226.     public function displayTicketAction(Request $request, $slug, $id)
  2227.     {
  2228.         $em = $this->getDoctrine()
  2229.                     ->getManager();
  2230.                     
  2231.         $boutique = $em->getRepository(Boutique::class)
  2232.                         ->findOneBySlug($slug);
  2233.         $user = $this->getUser();
  2234.         $userBoutique = $em->getRepository(UserBoutique::class)
  2235.                         ->findOneBy(
  2236.                             array(
  2237.                             'user' => $user->getId(),
  2238.                             'boutique' => $boutique->getId()
  2239.                             )
  2240.                         );
  2241.         
  2242.         $ticket = $em->getRepository(Ticket::class)
  2243.                     ->findOneBy(
  2244.                         array(
  2245.                             'boutique' => $boutique->getId(),
  2246.                             'id' => $id
  2247.                         )
  2248.                     );
  2249.         $commentaires = $em->getRepository(CommentaireTicket::class)
  2250.                             ->findByTicket($ticket->getId());
  2251.         $commentaireTicket = new CommentaireTicket;
  2252.         
  2253.         $user = $this->getUser();
  2254.         $form = $this->createForm(CommentaireTicketType::class, $commentaireTicket);
  2255.         
  2256.         $ok_soumission = '';
  2257.         $error = '';
  2258.         
  2259.         if($request->getMethod() == 'POST'){
  2260.             
  2261.                $form->handleRequest($request);
  2262.                if($form->isValid()){
  2263.                    
  2264.                    $commentaireTicket->setTicket($ticket);
  2265.                    $commentaireTicket->setUser($user);
  2266.                    
  2267.                   $em->persist($commentaireTicket);
  2268.                   $em->flush();
  2269.                 
  2270.                 $commentaires = $em->getRepository(CommentaireTicket::class)
  2271.                             ->findByTicket($ticket->getId());
  2272.                 $ok_soumission =" Votre message a été pris en compte";
  2273.                     
  2274.                 $commentaireTicket = new CommentaireTicket;
  2275.                 
  2276.                 
  2277.                 $form = $this->createForm(CommentaireTicketType::class, $commentaireTicket);
  2278.                     
  2279.                 } else {
  2280.                     $error =" Veillez corrigez vos erreurs";
  2281.                 }
  2282.         }
  2283.         
  2284.         return $this->render('gestion/display_ticket.html.twig', [
  2285.            'boutique' => $boutique,
  2286.            'ticket' => $ticket,
  2287.            'form' => $form->createView(),
  2288.            'commentaires' => $commentaires,
  2289.            'userBoutique' => $userBoutique
  2290.         ]);
  2291.     }
  2292.     
  2293.     /**
  2294.      * @Route("/{slug}/close-ticket/{id}", name="gestion.close_ticket")
  2295.      * @return \Symfony\Component\HttpFoundation\Response
  2296.      */
  2297.     public function closeTicketAction(Request $request, $slug, $id)
  2298.     {
  2299.         $em = $this->getDoctrine()
  2300.                     ->getManager();
  2301.                     
  2302.         $boutique = $em->getRepository(Boutique::class)
  2303.                         ->findOneBySlug($slug);
  2304.         
  2305.         $ticket = $em->getRepository(Ticket::class)
  2306.                     ->findOneBy(
  2307.                         array(
  2308.                             'boutique' => $boutique->getId(),
  2309.                             'id' => $id
  2310.                         )
  2311.                     );
  2312.         
  2313.         if(null !== $ticket){
  2314.             $ticket->setLesCommentairesSontFermes(true);
  2315.             $em->flush();
  2316.         }
  2317.         
  2318.         return $this->redirectToRoute('gestion.display_ticket',array('slug'=>$boutique->getSlug(), 'id'=>$ticket->getId()));
  2319.     }
  2320.     
  2321.     
  2322.     /**
  2323.      * @Route("/{slug}/delete-ticket/{id}", name="gestion.delete_ticket")
  2324.      * @return \Symfony\Component\HttpFoundation\Response
  2325.      */
  2326.     public function deleteTicketAction(Request $request, $slug, $id)
  2327.     {
  2328.         $em = $this->getDoctrine()
  2329.                     ->getManager();
  2330.                     
  2331.         $boutique = $em->getRepository(Boutique::class)
  2332.                         ->findOneBySlug($slug);
  2333.         $user = $this->getUser();
  2334.         
  2335.         
  2336.         $ok_soumission = '';
  2337.         $error = '';
  2338.         
  2339.         $ticket = $em->getRepository(Ticket::class)
  2340.                     ->findOneBy(
  2341.                         array(
  2342.                             'boutique' => $boutique->getId(),
  2343.                             'id' => $id
  2344.                         )
  2345.                     );
  2346.         if(null !== $ticket){
  2347.             $commentaireTickets = $em->getRepository(CommentaireTicket::class)
  2348.                                     ->findByTicket($ticket->getId());
  2349.             foreach($commentaireTickets as $commentaireTicket)
  2350.             {
  2351.                 $em->remove($commentaireTicket);
  2352.             }
  2353.             $em->remove($ticket);
  2354.             $em->flush();
  2356.         }
  2357.         
  2358.         return $this->redirectToRoute('gestion.tickets',array('slug'=>$boutique->getSlug(), 'id'=>$user->getId()));
  2359.     }
  2360.     
  2361.     
  2362.     /**
  2363.      * @Route("/{slug}/delete-commentaire-ticket/{id}", name="gestion.delete_commentaire_ticket")
  2364.      * @return \Symfony\Component\HttpFoundation\Response
  2365.      */
  2366.     public function deleteCommentaireTicketAction(Request $request, $slug, $id)
  2367.     {
  2368.         $em = $this->getDoctrine()
  2369.                     ->getManager();
  2370.                     
  2371.         $boutique = $em->getRepository(Boutique::class)
  2372.                         ->findOneBySlug($slug);
  2373.         $user = $this->getUser();
  2374.     
  2375.         $commentaireTicket = $em->getRepository(CommentaireTicket::class)
  2376.                     ->findOneById($id);
  2377.                     
  2378.         if(null !== $commentaireTicket){
  2379.             
  2380.             $em->remove($commentaireTicket);
  2381.             $em->flush();
  2383.         }
  2384.         
  2385.         return $this->redirectToRoute('gestion.tickets',array('slug'=>$boutique->getSlug(), 'id'=>$user->getId()));
  2386.     }
  2387.     
  2388.     /**
  2389.      * @Route("/{slug}/reviews", name="gestion.reviews")
  2390.      */
  2391.     public function reviewsAction(Boutique $boutique)
  2392.     {
  2393.         $em = $this->getDoctrine()->getManager();
  2394.         $user = $this->getUser();
  2395.         $reviews = $em->getRepository(AvisUtilisateur::class)
  2396.                         ->findByBoutique($boutique);
  2397.         $notifications = $em->getRepository(Notification::class)
  2398.                                         ->findBy(
  2399.                                             array(
  2400.                                             'user' => $user,
  2401.                                             'vu'  => false,
  2402.                                             'typeNotification' => 'avis'
  2403.                                             )
  2404.                                         );
  2405.         foreach($notifications as $notification){
  2406.             $notification->setVu(true);
  2407.         }
  2408.         $em->flush();
  2409.           return $this->render('gestion/reviews.html.twig', [
  2410.           'reviews' => $reviews,
  2411.           'boutique' => $boutique
  2412.         ]);
  2413.         
  2414.     }
  2415.     
  2416.     /**
  2417.      * @Route("/{id}/delete-review", name="gestion.delete_review")
  2418.      */
  2419.     public function deleteReviewAction(AvisUtilisateur $review)
  2420.     {
  2421.         $em = $this->getDoctrine()->getManager();
  2422.         $slug = $review->getBoutique()->getSlug();
  2423.         $em->remove($review);
  2424.         $em->flush();
  2425.         
  2426.         return $this->redirectToRoute('gestion.reviews', array('slug' => $slug));
  2427.     }
  2428.     
  2429.     /**
  2430.      * @Route("/{id}/reply-review", name="gestion.reply_review")
  2431.      */
  2432.     public function replyReviewAction(Request $request, AvisUtilisateur $review)
  2433.     {
  2434.         $em = $this->getDoctrine()->getManager();
  2435.         
  2436.         if($request->getMethod() == 'POST'){
  2437.             $reponseAvis = $request->request->get('reponseAvis');
  2438.             $review->setReponseAvis($reponseAvis);
  2439.             $em->flush();
  2440.             
  2441.             $slug = $review->getBoutique()->getSlug();
  2442.             return $this->redirectToRoute('gestion.reviews', array('slug' => $slug));
  2443.         }
  2444.     
  2445.           return $this->render('gestion/reply_review.html.twig', [
  2446.           'review' => $review,
  2447.           'boutique' => $review->getBoutique()
  2448.         ]);
  2449.         
  2450.     }
  2451.     
  2452.     /**
  2453.      * @Route("/{slug}/messages", name="gestion.messages")
  2454.      */
  2455.     public function messagesAction(Boutique $boutique)
  2456.     {
  2457.         $em = $this->getDoctrine()->getManager();
  2458.         
  2459.         $conversations = $em->getRepository(Conversation::class)
  2460.                         ->findByBoutique($boutique);
  2461.         $user = $this->getUser();
  2462.         
  2463.         
  2464.     
  2465.         return $this->render('gestion/messages.html.twig', [
  2466.           'conversations' => $conversations,
  2467.           'boutique' => $boutique
  2468.         ]);
  2469.         
  2470.     }
  2471.     
  2472.     /**
  2473.      * @Route("/{slug}/{id}/conversation", name="gestion.one_conversation")
  2474.      */
  2475.     public function oneConversationAction(Request $request, $slug, $id)
  2476.     {
  2477.         $em = $this->getDoctrine()->getManager();
  2478.         
  2479.         $boutique = $em->getRepository(Boutique::class)
  2480.                         ->findOneBySlug($slug);
  2481.         $user = $this->getUser();                
  2482.         $notifications = $em->getRepository(Notification::class)
  2483.                                         ->findBy(
  2484.                                             array(
  2485.                                             'user' => $user,
  2486.                                             'vu'  => false,
  2487.                                             'typeNotification' => 'message',
  2488.                                             'extraData' => $id
  2489.                                             )
  2490.                                         );
  2491.         foreach($notifications as $notification){
  2492.             $notification->setVu(true);
  2493.         }
  2494.         $em->flush();
  2495.         
  2496.         $conversation = $em->getRepository(Conversation::class)
  2497.                         ->findOneById($id);
  2498.                         
  2499.         if($request->getMethod() == 'POST'){
  2500.             $reponseMessage = $request->request->get('reponseMessage');
  2501.             
  2502.             $message = new Message;
  2503.             $message->setContenu($reponseMessage);
  2504.             $message->setConversation($conversation);
  2505.             $em->persist($message);
  2506.             $em->flush();
  2507.             
  2508.             $notification = new Notification;
  2509.             $notification->setUser($conversation->getUser());
  2510.             $lien =  $this->generateUrl('profile.one_conversation', array('slug'=>$conversation->getBoutique()->getSlug(), 'id' => $conversation->getId()));
  2511.             $notification->setExtraData($conversation->getId());
  2512.             $notification->setLien($lien);
  2513.             $notification->setTypeNotification('message');
  2514.             $notification->setDescription('Vous avez un nouveau message');
  2515.             
  2516.             $conversation->setLastMessage($reponseMessage);
  2517.         
  2518.             $em->persist($notification);
  2519.             $em->flush();    
  2520.             
  2521.         }
  2522.         
  2523.         $messages = $em->getRepository(Message::class)
  2524.                     ->findBy(
  2525.                         array(
  2526.                             'conversation' => $conversation
  2527.                         )
  2528.             );
  2529.     
  2530.           return $this->render('gestion/one_conversation.html.twig', [
  2531.           'conversation' => $conversation,
  2532.           'boutique' => $boutique,
  2533.           'messages' => $messages
  2534.         ]);
  2535.     }
  2536.     
  2537.     /**
  2538.      * @Route("/notification-to-join-team/{email}", name="notification_requette_ajout_boutique")
  2539.      * @return \Symfony\Component\HttpFoundation\Response
  2540.      */
  2541.     public function notificationRequetteAjoutBoutiqueAction(Request $request,  $email)
  2542.     {
  2543.               
  2544.         $em = $this->getDoctrine()
  2545.                     ->getManager();
  2546.         
  2547.             
  2548.         $requeteBoutiques = $em->getRepository(RequeteAjoutBoutique::class)
  2549.                         ->findBy(
  2550.                             array(
  2551.                                 'email' => $email
  2552.                             )
  2553.                             );
  2554.                             
  2555.         $nbRequete = count($requeteBoutiques);
  2556.         
  2557.         return $this->render('entreprise/notification_requette_ajout_boutique.html.twig', [
  2558.            'nbRequete' => $nbRequete
  2559.         ]);
  2560.         
  2561.     }
  2562.     
  2563.     /**
  2564.      * @Route("/request-to-join-team/{email}", name="afficher_requette_ajout_boutique")
  2565.      * @return \Symfony\Component\HttpFoundation\Response
  2566.      */
  2567.     public function afficherRequetteAjoutBoutiqueAction(Request $request,  $email)
  2568.     {
  2569.               
  2570.         $em = $this->getDoctrine()
  2571.                     ->getManager();
  2572.             
  2573.         $requeteBoutiques = $em->getRepository(RequeteAjoutBoutique::class)
  2574.                         ->findByEmail($email);
  2575.                         
  2576.         foreach($requeteBoutiques as $requeteBoutique){
  2577.             $requeteBoutique->setVu(true);
  2578.         }
  2579.         
  2580.         $em->flush();
  2581.         
  2582.         return $this->render('entreprise/afficher_requette_ajout_boutique.html.twig', [
  2583.            'requeteBoutiques' => $requeteBoutiques
  2584.         ]);
  2585.         
  2586.     }
  2587.     
  2588.     /**
  2589.      * @Route("/respond-request-to-join-team/{id}/{status}", name="repondre_requette_ajout_boutique")
  2590.      * @return \Symfony\Component\HttpFoundation\Response
  2591.      */
  2592.     public function repondreRequetteAjoutBoutiqueAction(Request $request,  $id, $status)
  2593.     {
  2594.               
  2595.         $em = $this->getDoctrine()
  2596.                     ->getManager();
  2597.             
  2598.         $requeteAjout = $em->getRepository(RequeteAjoutBoutique::class)
  2599.                         ->findOneById($id);
  2600.         $user = $this->getUser();    
  2601.         if($status){
  2602.             $userBoutique = $em->getRepository(UserBoutique::class)
  2603.                                 ->findOneBy(
  2604.                                     array(
  2605.                                         'user' => $user->getId(),
  2606.                                         'boutique' => $requeteAjout->getBoutique()->getId()
  2607.                                     )
  2608.                                 );
  2609.             if(null === $userBoutique){
  2610.                 $userBoutique = new UserBoutique;
  2611.                 $userBoutique->setUser($user);
  2612.                 $userBoutique->setBoutique($requeteAjout->getBoutique());
  2613.                 $userBoutique->setRole($requeteAjout->getRole());
  2614.                 $em->persist($userBoutique);
  2615.             }
  2616.         } 
  2617.         $em->remove($requeteAjout);
  2618.         $em->flush();
  2619.         
  2620.         return $this->redirectToRoute('home');
  2621.         
  2622.     }
  2623.     
  2624.     public function getDomain()
  2625.     {
  2626.         $domaine = $_SERVER['HTTP_HOST'];
  2627.         $protocol = '';
  2628.         if(!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off'){
  2629.             $protocol = 'https://';
  2630.         } else{
  2631.             $protocol = 'http://';
  2632.         }
  2633.         
  2634.         return $protocol.$domaine;
  2635.     }
  2636.     
  2637.         public function gererFichierMultipleLogo(\App\Entity\Boutique $boutique, $data)
  2638.         {
  2639.             
  2640.             $ex = pathinfo($data['name'])['extension'];
  2641.             $exA = array('jpg', 'jpeg', 'png', 'gif', 'svg');
  2642.             
  2643.             if (!in_array(strtolower($ex), $exA)){
  2644.                 throw new \RuntimeException('Désolé, vous n\'avez pas le droit de télécharger ce type de fichier: '.$ex);
  2645.             }
  2646.             
  2647.             $name = $boutique->getId().time();
  2648.             $namePourRepertoire = $name;
  2649.             //hydratation des attributs de l'objet
  2650.             
  2651.             $domaine = $_SERVER['HTTP_HOST'];
  2652.             $protocol = '';
  2653.             if(!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off'){
  2654.                 $protocol = 'https://';
  2655.             } else{
  2656.                 $protocol = 'http://';
  2657.             }
  2658.             $url = $protocol.$domaine.'/uploads/img/logo/'.$name.'.'.$ex;
  2659.             $boutique->getLogo()->setUrl($url);
  2660.             $boutique->getLogo()->setAlt('Logo '.$boutique->getNom());
  2661.             
  2662.             //deplacement (création de l'image original)
  2663.             //$this->file->move($photo->getUploadRootDir().'/original/', $name.'.'.photo->getExtension()));
  2664.             
  2665.             
  2666.             if(!is_dir($boutique->getLogo()->getUploadRootDir().'/featured/') && !mkdir($boutique->getLogo()->getUploadRootDir().'/featured', 0777, true))
  2667.             {
  2668.                 throw new \RuntimeException('Impossible de créer le dossier de destination');
  2669.             }
  2670.             
  2671.             if (!move_uploaded_file($data['tmp_name'], $boutique->getLogo()->getUploadRootDir().'/featured/'.$name.'.'.$ex))
  2672.             {
  2673.                 throw new \RuntimeException('Désolé, une erreur s\'est produite.');
  2674.             }
  2675.                     
  2676.         $name = $boutique->getLogo()->getUploadRootDir().'/featured/'.$name.'.'.$ex;
  2677.         $extension = strtolower($ex);
  2678.             try{
  2679.                         $nvlleImgMenu = ( $extension =='jpg' || $extension == 'jpeg') ? imagecreatefromjpeg($name) : imagecreatefrompng($name);
  2680.                         
  2681.                         $miniatureMenu = imagecreatetruecolor(48, 48);
  2682.                         
  2683.                         $largeurNvlleImgMenu = imagesx($nvlleImgMenu);
  2684.                         $hauteurNvlleImgMenu = imagesy($nvlleImgMenu);
  2685.                         $largeurMiniatureMenu = imagesx($miniatureMenu);
  2686.                         $hauteurMiniatureMenu = imagesy($miniatureMenu);
  2687.                         
  2688.                         //fusion et generation des miniatures
  2689.                         
  2690.                         imagecopyresampled($miniatureMenu, $nvlleImgMenu, 0, 0, 0, 0, $largeurMiniatureMenu, $hauteurMiniatureMenu,
  2691.                                    $largeurNvlleImgMenu, $hauteurNvlleImgMenu);
  2692.                         
  2693.                         //deplacer les nouvelles images(miniatures) dans les repertoires correspondants
  2694.                         
  2695.                         if(!is_dir($boutique->getLogo()->getUploadRootDir().'/logo/') && !mkdir($boutique->getLogo()->getUploadRootDir().'/logo/', 0777, true)){
  2696.                             throw \RuntimeException('Impossible de créer le dossier de destination');
  2697.                         }
  2698.                         $name = $boutique->getLogo()->getUploadRootDir().'/logo/'.$namePourRepertoire.'.'.$extension;
  2699.                         if($extension == 'jpg' || $extension == 'jpeg'){
  2700.                             imagejpeg($miniatureMenu, $name, 90);
  2701.                         } else{
  2702.                             imagepng($miniatureMenu, $name, 9);
  2703.                         }
  2704.                         $fromSecure = 'http://';
  2705.                         if( isset($_SERVER['HTTPS'] ) ){
  2706.                             $fromSecure = 'https://';
  2707.                         }
  2708.                         $boutique->getLogo()->setUrl($fromSecure.$_SERVER['HTTP_HOST'].'/uploads/img/logo/'.$namePourRepertoire.'.'.$extension);
  2709.                     
  2710.                         //
  2711.                     } catch(Exception $e){
  2712.                     }
  2713.                     
  2714.         
  2715.         
  2716.         $this->getDoctrine()->getManager()->flush();
  2717.         
  2718.     }
  2721.     
  2722.     public function gererFichierMultiple(\App\Entity\Produit $produit, $data, $imagePrincipale = false)
  2723.     {
  2724.         $nbFichier = 0; 
  2725.         
  2726.         if($imagePrincipale){
  2727.             
  2728.                 $photo = new ProductPhoto;
  2729.                 $photo->setFile($data);
  2730.                 
  2731.                 $produit->setImagePrincipale($photo);
  2732.                 
  2733.                 $ex = pathinfo($data['name'])['extension'];
  2734.                 $exA = array('jpg', 'jpeg', 'png', 'gif');
  2735.                 
  2736.                 if (in_array(strtolower($ex), $exA)){
  2737.                 
  2738.                     $photo->setExtension($ex);
  2739.                 } else {
  2740.                     throw new \RuntimeException('Désolé, vous n\'avez pas le droit de télécharger ce type de fichier: '.$ex);
  2741.                 }
  2742.                 
  2743.                 $name = $produit->getId().time();
  2744.                 $namePourRepertoire = $name;
  2745.                 //hydratation des attributs de l'objet
  2746.                 $photo->setUrl($name.'.'.$photo->getExtension());
  2747.                 $photo->setAlt('Image de '.$produit->getNom());
  2748.                 $extension = $photo->getExtension();
  2749.                 //deplacement (création de l'image original)
  2750.                 //$this->file->move($photo->getUploadRootDir().'/original/', $name.'.'.photo->getExtension()));
  2751.                 
  2752.                 
  2753.                 if(!is_dir($photo->getUploadRootDir().'/original/') && !mkdir($photo->getUploadRootDir().'/original', 0777, true))
  2754.                 {
  2755.                     throw new \RuntimeException('Impossible de créer le dossier de destination');
  2756.                 }
  2757.                 
  2758.                 if (!move_uploaded_file($data['tmp_name'], $photo->getUploadRootDir().'/original/'.$name.'.'.$photo->getExtension()))
  2759.                 {
  2760.                     throw new \RuntimeException('Désolé, une erreur s\'est produite.');
  2761.                 }
  2762.                 try{
  2763.                     $name = $photo->getUploadRootDir().'/original/'.$name.'.'.$photo->getExtension();
  2764.                         $nvlleImgMenu = ( $ex =='jpg' || $ex == 'jpeg') ? imagecreatefromjpeg($name) : imagecreatefrompng($name);
  2765.                         
  2766.                         $miniatureMenu = imagecreatetruecolor(600, 600);
  2767.                         
  2768.                         $largeurNvlleImgMenu = imagesx($nvlleImgMenu);
  2769.                         $hauteurNvlleImgMenu = imagesy($nvlleImgMenu);
  2770.                         $largeurMiniatureMenu = imagesx($miniatureMenu);
  2771.                         $hauteurMiniatureMenu = imagesy($miniatureMenu);
  2772.                         
  2773.                         //fusion et generation des miniatures
  2774.                         
  2775.                         imagecopyresampled($miniatureMenu, $nvlleImgMenu, 0, 0, 0, 0, $largeurMiniatureMenu, $hauteurMiniatureMenu,
  2776.                                    $largeurNvlleImgMenu, $hauteurNvlleImgMenu);
  2777.                         
  2778.                         //deplacer les nouvelles images(miniatures) dans les repertoires correspondants
  2779.                         
  2780.                         if(!is_dir($photo->getUploadRootDir().'/featured/') && !mkdir($photo->getUploadRootDir().'/featured/', 0777, true)){
  2781.                             throw \RuntimeException('Impossible de créer le dossier de destination');
  2782.                         }
  2783.                         $name = $photo->getUploadRootDir().'/featured/'.$photo->getUrl();
  2784.                         if($extension == 'jpg' || $extension == 'jpeg'){
  2785.                             imagejpeg($miniatureMenu, $name, 85);
  2786.                         } else{
  2787.                             imagepng($miniatureMenu, $name, 8);
  2788.                         }
  2789.                         $fromSecure = 'http://';
  2790.                         if( isset($_SERVER['HTTPS'] ) ){
  2791.                             $fromSecure = 'https://';
  2792.                         }
  2793.                         $photo->setUrl($fromSecure.$_SERVER['HTTP_HOST'].'/'.$photo->getUploadDir().'/featured/'.$photo->getUrl());
  2794.                     
  2795.                         //
  2796.                     } catch(Exception $e){
  2797.                     }
  2798.                 $this->getDoctrine()->getManager()->persist($photo);                
  2799.         } else{
  2800.             $tableauFichier = $this->reArrayFiles($data);
  2801.             //var_dump($tableauFichier);
  2802.             $i = 0;
  2803.             foreach ($tableauFichier as $file)
  2804.             {
  2805.                 $i++;
  2806.             //print 'File Name: ' . $file['name'];
  2807.             //print 'File Type: ' . $file['type'];
  2808.             //print 'File Size: ' . $file['size'];
  2809.         
  2810.             
  2811.                 $photo = new ProductPhoto;
  2812.                 $photo->setFile($file);
  2813.                 
  2814.                 
  2815.                 
  2816.                 $ex = pathinfo($file['name'])['extension'];
  2817.                 $exA = array('jpg', 'jpeg', 'png', 'gif');
  2818.                 
  2819.                 if (in_array(strtolower($ex), $exA)){
  2820.                 
  2821.                     $photo->setExtension($ex);
  2822.                 } else {
  2823.                     throw new \RuntimeException('Désolé, vous n\'avez pas le droit de télécharger ce type de fichier: '.$ex);
  2824.                 }
  2825.                 
  2826.                 $name = $produit->getId().$i.time();
  2827.                 $namePourRepertoire = $name;
  2828.                 //hydratation des attributs de l'objet
  2829.                 $photo->setUrl($name.'.'.$photo->getExtension());
  2830.                 $photo->setAlt('Image de '.$produit->getNom());
  2831.                 $fromSecure = 'http://';
  2832.                         if( isset($_SERVER['HTTPS'] ) ){
  2833.                             $fromSecure = 'https://';
  2834.                         }
  2835.                 $photo->setUrl($fromSecure.$_SERVER['HTTP_HOST'].'/'.$photo->getUploadDir().'/original/'.$photo->getUrl());
  2836.                     
  2837.                 //deplacement (création de l'image original)
  2838.                 //$this->file->move($photo->getUploadRootDir().'/original/', $name.'.'.photo->getExtension()));
  2839.                 
  2840.                 $produit->addPhoto($photo);
  2841.                 if(!is_dir($photo->getUploadRootDir().'/original/') && !mkdir($photo->getUploadRootDir().'/original', 0777, true))
  2842.                 {
  2843.                     throw new \RuntimeException('Impossible de créer le dossier de destination');
  2844.                 }
  2845.                 
  2846.                 if (!move_uploaded_file($file['tmp_name'], $photo->getUploadRootDir().'/original/'.$name.'.'.$photo->getExtension()))
  2847.                 {
  2848.                     throw new \RuntimeException('Désolé, une erreur s\'est produite.');
  2849.                 }
  2850.                 $this->getDoctrine()->getManager()->persist($photo);
  2851.         }
  2852.         }
  2853.         
  2854.         $this->getDoctrine()->getManager()->flush();
  2855.         
  2856.     }
  2857.     
  2858.     public function reArrayFiles($file_post)
  2859.     {
  2861.         $file_ary = array();
  2862.         $file_count = count($file_post['name']);
  2863.         $file_keys = array_keys($file_post);
  2865.         for ($i=0; $i<$file_count; $i++)
  2866.         {
  2867.             foreach ($file_keys as $key)
  2868.             {
  2869.                 $file_ary[$i][$key] = $file_post[$key][$i];
  2870.             }
  2871.         }
  2873.         return $file_ary;
  2874.     }
  2875.     
  2877.     public function allowRemoteRequest($response)
  2878.     {
  2879.         
  2880.         $response->headers->set('Access-Control-Allow-Origin', '*');
  2881.         $response->headers->set('Content-Type', 'application/json;');
  2882.         $response->headers->set('Access-Control-Allow-Headers', 'Origin, Accept, X-Requested-With, Content-Type, Access-Control-Request-Method, Access-Control-Allow-Origin,Authorization,Access-Control-Request-Headers');
  2883.         
  2884.         //$response->headers->set('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, PUT, PATCH, DELETE');
  2885.         //$response->headers->set('Access-Control-Allow-Headers', 'Origin, Accept, Access-Control-Allow-Origin, Content-Type, X-Auth-Token');
  2886.         //$response->headers->set('Access-Control-Allow-Headers', 'Content-Type');
  2887.         
  2888.         //$response->headers->set('Access-Control-Allow-Credentials', true);
  2889.         //$response->headers->set('Access-Control-Allow-Headers', 'Access-Control-Allow-Origin, Origin, Accept, X-Requested-With, Content-Type, Access-Control-Request-Method, Authorization,Access-Control-Request-Headers');
  2890.         //$response->headers->set('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, PUT, PATCH, DELETE');
  2891.         
  2892.         //header("Access-Control-Allow-Headers: 'Origin, Accept, X-Requested-With, Content-Type, Access-Control-Request-Method, Access-Control-Allow-Origin,Authorization,Access-Control-Request-Headers'");
  2893.         return $response;
  2894.     }
  2896.     public function getJekoBaseUrl()
  2897.     {
  2898.       return 'https://api.jeko.africa/partner_api' ;
  2899.     }
  2901.     public function getJekoAPI()
  2902.     {
  2903.         return 'jeko_66ecb6a64777b553e7655db916e8cd8f3484344f86ee381d2adc80f56a1b25b6';
  2904.     }
  2906.     public function getJekoAPIID()
  2907.     {
  2908.         return $_ENV['JEKO_API_KEY_ID'] ?? getenv('JEKO_API_KEY_ID') ?: '2186eab1-2e47-47f7-98d3-71fd860fb7c2';
  2909.         
  2910.     }
  2912.     public function getJekoStoreId()
  2913.     {
  2914.         return 'e3248694-5eeb-4184-80f8-01b7c7a6e428';
  2915.     }
  2917.     
  2918. }