src/Controller/OrdersController.php line 51

  1. <?php
  3. namespace App\Controller;
  5. use App\Dto\MerchantPay\InitiateTransactionRequest;
  6. use App\Entity\Order;
  7. use App\Entity\Paiement;
  8. use App\Entity\Playlist;
  9. use App\Services\OrangeMoney;
  10. use App\Entity\PurchaceOrders;
  11. use App\Form\PaiementListType;
  12. use Symfony\Component\Uid\UuidV3;
  13. use App\Exception\MVolaApiException;
  14. use App\Repository\OrderRepository;
  15. use App\Repository\PaiementRepository;
  16. use App\Repository\PlaylistRepository;
  17. use App\Repository\UserRepository;
  18. use App\Services\MVolaApiService;
  19. use Doctrine\ORM\EntityManagerInterface;
  20. use Symfony\Component\HttpFoundation\Request;
  21. use Symfony\Component\HttpFoundation\Response;
  22. use Symfony\Component\Routing\Annotation\Route;
  23. use Symfony\Component\HttpFoundation\JsonResponse;
  24. use Symfony\Component\Security\Http\Attribute\IsGranted;
  25. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  26. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  27. use Symfony\Component\Serializer\SerializerInterface;
  28. use App\Services\StripePaymentService;
  29. use App\Services\AirtelMoney;
  30. use App\Exception\AirtelApiException;
  31. use Psr\Log\LoggerInterface;
  33. #[Route('/orders', name: 'app_orders')]
  34. class OrdersController extends AbstractController
  35. {
  37.    
  38.     
  39.     public function __construct(
  40.         private MVolaApiService $mvolaApiService,
  41.         private SerializerInterface $serializer, 
  42.         private StripePaymentService $stripePaymentService,
  43.         private AirtelMoney $airtelMoney,
  44.         private LoggerInterface $logger
  45.     ) {
  46.     }
  49.     #[Route('/', name: '_index')]
  50.     #[IsGranted('ROLE_USER')]
  51.     public function index(SessionInterface $sessionInterface,PlaylistRepository $playlistRepository): Response
  52.     {
  54.         $card = $sessionInterface->get('card', []);
  55.         $playlists = $playlistRepository->findBy(['id' => $card]);
  56.         return $this->render('orders/index.html.twig', [
  57.             'playlists' => $playlists,
  58.         ]);
  59.     }
  60.     
  62.     #[Route('/mycommande', name: '_mycommande')]
  63.     #[IsGranted('ROLE_USER')]
  64.     public function mycommande(OrderRepository $orderRepository): Response
  65.     {
  66.         $orders = $orderRepository->findBy(['client' => $this->getUser()],['id' => 'DESC']);
  67.         return $this->render('orders/mycommande.html.twig', [
  68.             'orders' => $orders,
  69.         ]);
  70.     }
  73.     #[Route('/commande', name: '_commande')]
  74.     #[IsGranted('ROLE_USER_ADMIN')]
  75.     public function commande(OrderRepository $orderRepository): Response
  76.     {
  77.         $orders = $orderRepository->findBy([],['id' => 'DESC']);
  78.         return $this->render('orders/commande.html.twig', [
  79.             'orders' => $orders,
  80.         ]);
  81.     }
  85.     //create order from card
  86.     #[Route('/createOrder', name: '_create')]
  87.     #[IsGranted('ROLE_USER')]
  88.     public function createOrder(SessionInterface $sessionInterface,EntityManagerInterface $entityManager): Response
  89.     {
  90.         $card = $sessionInterface->get('card', []);
  91.         if (count($card) > 0) {
  92.             $order = (new Order())
  93.                 ->setClient($this->getUser())
  94.                 ->setCeatedAt(new \DateTimeImmutable())
  95.                 ->setStatus('created')
  96.                 ;
  97.             $entityManager->persist($order);
  98.             $entityManager->flush();
  99.             foreach ($card as $playlistId) {
  100.                 $playlist = $entityManager->getRepository(Playlist::class)->find($playlistId);
  101.                 if (!$playlist) {
  102.                     continue;
  103.                 }
  104.                 $purchace = (new PurchaceOrders())
  105.                     ->setPlaylist($playlist)
  106.                     ->setAmount($playlist->getPrix())
  107.                     ->setOrders($order)
  108.                     ;
  109.                 $entityManager->persist($purchace);
  110.                 $entityManager->flush();
  111.             }
  113.             $sessionInterface->set('card', []);
  114.             return $this->redirectToRoute('app_orders_show', ['id' => $order->getId()]);
  115.         }
  116.         return $this->redirectToRoute('app_orders_index');
  117.     }
  119.     //order show
  120.     #[Route('/show/{id}', name: '_show')]
  121.     #[IsGranted('ROLE_USER')]
  122.     public function show(Order $order,Request $request, OrangeMoney $orangeMoney,EntityManagerInterface $entityManager,UserRepository $userRepository): Response
  123.     {
  124.         if ($order->getClient() != $this->getUser()) {
  125.             return $this->redirectToRoute('app_orders_index');
  126.         }
  127.         // create form PaymentList
  128.         $form = $this->createForm(PaiementListType::class);
  129.         $form->handleRequest($request);
  130.         if ($form->isSubmitted() && $form->isValid()) {
  131.             $data = $form->getData();
  132.             // calculer le montant total
  133.             $total = 0;
  134.             foreach ($order->getPurchaces() as $purchace) {
  135.                 $total += $purchace->getAmount();
  136.             }
  137.             if ($data['type'] == 'OrangeMoney') {
  138.                 
  139.                 //create paiement with orangemoney
  140.                 $response = $orangeMoney->initiateWebPayment($total, $order->getUid(), $this->generateUrl('app_orders_index', [], true));
  141.                 if ($response['status'] == 201) {
  142.                     $paiement = new Paiement();
  143.                     $paiement->setOrders($order);
  144.                     $paiement->setType('OrangeMoney');
  145.                     $paiement->setAmount($total);
  146.                     $paiement->setStatus('pending');
  147.                     $paiement->setOmPayToken($response['pay_token']);
  148.                     $paiement->setOmNotifToken($response['notif_token']);
  149.                     $entityManager->persist($paiement);
  150.                     $entityManager->flush();
  151.                     $this->addFlash('success', 'Paiement effectué avec succès');
  152.                     return $this->redirect($response['payment_url']);
  154.                 } else {
  155.                     $this->addFlash('error', 'Erreur de paiement');
  156.                 }
  158.                 $order->setStatus('pending');
  159.             } elseif ($data['type'] == 'MVola') {
  160.                 try {
  161.                     $user = $userRepository->findOneBy(['phone' => $this->getUser()->getUserIdentifier()]);
  162.                     
  163.                     if (!$user || !$user->getPhone()) {
  164.                         $this->addFlash('error', 'Numéro de téléphone non trouvé pour l\'utilisateur.');
  165.                         return $this->redirectToRoute('app_orders_show', ['id' => $order->getId()]);
  166.                     }
  167.                     
  168.                     $customerMsisdn = $user->getPhone();
  169.                     $partnerMsisdn = $this->mvolaApiService->getPartnerMsisdn();
  171.                     // En environnement de développement, MVola impose l'utilisation
  172.                     // de MSISDN de test. On force donc le numéro client sur le MSISDN
  173.                     // de test fourni par Telma pour la sandbox.
  174.                     if ($this->getParameter('kernel.environment') === 'dev') {
  175.                         // Numéros de test officiels MVola (Telma) pour sandbox :
  176.                         // 0343500003, 0343500004
  177.                         // On utilise le premier comme client (débit).
  178.                         $customerMsisdn = '0343500004';
  179.                     }
  180.                     
  181.                     // Convertir le montant en chaîne sans décimales (selon la documentation MVola)
  182.                     $amountString = (string) intval($total);
  183.                     
  184.                     // Préparer la requête DTO
  185.                     $requestDto = new InitiateTransactionRequest();
  186.                     $requestDto->amount = $amountString;
  187.                     $requestDto->currency = 'Ar';
  188.                     $requestDto->setDebitPartyMsisdn($customerMsisdn);
  189.                     $requestDto->setCreditPartyMsisdn($partnerMsisdn);
  190.                     $requestDto->descriptionText = 'Paiement commande ' . $order->getId();
  191.                     $requestDto->requestingOrganisationTransactionReference = 'order_' . $order->getId() . '_' . time();
  192.                     $requestDto->setPartnerName('edena');
  193.                     $requestDto->setForeignCurrency('USD', '1');
  194.                     
  195.                     // Générer l'URL de callback
  196.                     $callbackUrl = $this->generateUrl('app_orders_api_mvola_callback', [], \Symfony\Component\Routing\Generator\UrlGeneratorInterface::ABSOLUTE_URL);
  197.                     
  198.                     $this->logger->info('MVola: Tentative d\'initiation de transaction', [
  199.                         'order_id' => $order->getId(),
  200.                         'amount' => $amountString,
  201.                         'customer' => $customerMsisdn,
  202.                         'partner' => $partnerMsisdn,
  203.                         'callback_url' => $callbackUrl
  204.                     ]);
  205.                     
  206.                     // Initier la transaction
  207.                     $response = $this->mvolaApiService->initiateTransaction($requestDto, $callbackUrl);
  208.                     
  209.                     // Enregistrer le paiement en base
  210.                     $paiement = new Paiement();
  211.                     $paiement->setOrders($order);
  212.                     $paiement->setType('MVola');
  213.                     $paiement->setAmount((int) $total);
  214.                     $paiement->setStatus('pending');
  215.                     // Pour MVola, on stocke le serverCorrelationId dans om_pay_token
  216.                     // car les callbacks et vérifications utilisent ce champ.
  217.                     $paiement->setOmPayToken($response->serverCorrelationId);
  218.                     // On garde aussi une colonne dédiée CorrelationId pour suivi interne.
  219.                     $paiement->setCorrelationId($response->serverCorrelationId);
  220.                     $paiement->setOmNotifToken(null);
  221.                     $entityManager->persist($paiement);
  222.                     
  223.                     // Mettre à jour le statut de la commande
  224.                     $order->setStatus('pending');
  225.                     $entityManager->flush();
  227.                     $this->addFlash('success', 'Paiement MVola initié avec succès. Veuillez valider la transaction sur votre téléphone.');
  228.                     return $this->redirectToRoute('app_orders_show', ['id' => $order->getId()]);
  229.                     
  230.                 } catch (MVolaApiException $e) {
  231.                     $errorMessage = 'Erreur MVola : ' . $e->getMessage();
  232.                     $errorDetails = [
  233.                         'message' => $e->getMessage(),
  234.                         'code' => $e->getCode(),
  235.                         'file' => $e->getFile(),
  236.                         'line' => $e->getLine(),
  237.                         'trace' => $e->getTraceAsString()
  238.                     ];
  239.                     
  240.                     $this->logger->error('MVola API Exception', $errorDetails);
  241.                     
  242.                     if ($this->getParameter('kernel.environment') === 'dev') {
  243.                         $errorMessage .= ' | Fichier: ' . basename($e->getFile()) . ':' . $e->getLine();
  244.                         if ($e->getErrorData()) {
  245.                             $errorMessage .= ' | Détails: ' . json_encode($e->getErrorData());
  246.                         }
  247.                     }
  248.                     
  249.                     $this->addFlash('error', $errorMessage);
  250.                     return $this->redirectToRoute('app_orders_show', ['id' => $order->getId()]);
  251.                     
  252.                 } catch (\Exception $e) {
  253.                     $errorDetails = [
  254.                         'message' => $e->getMessage(),
  255.                         'code' => $e->getCode(),
  256.                         'file' => $e->getFile(),
  257.                         'line' => $e->getLine(),
  258.                         'trace' => $e->getTraceAsString()
  259.                     ];
  260.                     
  261.                     $this->logger->error('MVola Exception générique', $errorDetails);
  262.                     
  263.                     $errorMessage = 'Une erreur est survenue lors de l\'initiation du paiement MVola.';
  264.                     if ($this->getParameter('kernel.environment') === 'dev') {
  265.                         $errorMessage .= ' | Erreur: ' . $e->getMessage() . ' | Fichier: ' . basename($e->getFile()) . ':' . $e->getLine();
  266.                     }
  267.                     
  268.                     $this->addFlash('error', $errorMessage);
  269.                     return $this->redirectToRoute('app_orders_show', ['id' => $order->getId()]);
  270.                 }
  271.             } elseif ($data['type'] == 'AirtelMoney') {
  272.                 try {
  273.                     $user = $userRepository->findOneBy(['phone' => $this->getUser()->getUserIdentifier()]);
  274.                     
  275.                     if (!$user || !$user->getPhone()) {
  276.                         $this->addFlash('error', 'Numéro de téléphone non trouvé pour l\'utilisateur.');
  277.                         return $this->redirectToRoute('app_orders_show', ['id' => $order->getId()]);
  278.                     }
  279.                     
  280.                     $customerMsisdn = $user->getPhone();
  281.                     $transactionId = 'order_' . $order->getId() . '_' . time();
  282.                     
  283.                     // Générer l'URL de callback
  284.                     $callbackUrl = $this->generateUrl('app_orders_api_airtel_callback', [], \Symfony\Component\Routing\Generator\UrlGeneratorInterface::ABSOLUTE_URL);
  285.                     
  286.                     $this->logger->info('Airtel Money: Tentative d\'initiation de paiement', [
  287.                         'order_id' => $order->getId(),
  288.                         'amount' => $total,
  289.                         'customer' => $customerMsisdn,
  290.                         'transaction_id' => $transactionId,
  291.                         'callback_url' => $callbackUrl
  292.                     ]);
  293.                     
  294.                     // Initier le paiement
  295.                     $response = $this->airtelMoney->initiatePayment(
  296.                         $total,
  297.                         $customerMsisdn,
  298.                         $transactionId,
  299.                         'Commande ' . $order->getId(),
  300.                         $callbackUrl
  301.                     );
  302.                     
  303.                     // Enregistrer le paiement en base
  304.                     $paiement = new Paiement();
  305.                     $paiement->setOrders($order);
  306.                     $paiement->setType('AirtelMoney');
  307.                     $paiement->setAmount((int) $total);
  308.                     $paiement->setStatus('pending');
  309.                     $paiement->setOmPayToken($response['transaction_id']);
  310.                     $paiement->setOmNotifToken(null);
  311.                     $entityManager->persist($paiement);
  312.                     
  313.                     // Mettre à jour le statut de la commande
  314.                     $order->setStatus('pending');
  315.                     $entityManager->flush();
  317.                     $this->addFlash('success', 'Paiement Airtel Money initié avec succès. Veuillez valider la transaction sur votre téléphone.');
  318.                     return $this->redirectToRoute('app_orders_show', ['id' => $order->getId()]);
  319.                     
  320.                 } catch (AirtelApiException $e) {
  321.                     $errorMessage = 'Erreur Airtel Money : ' . $e->getMessage();
  322.                     $errorDetails = [
  323.                         'message' => $e->getMessage(),
  324.                         'code' => $e->getCode(),
  325.                         'file' => $e->getFile(),
  326.                         'line' => $e->getLine(),
  327.                         'trace' => $e->getTraceAsString()
  328.                     ];
  329.                     
  330.                     $this->logger->error('Airtel Money API Exception', $errorDetails);
  331.                     
  332.                     if ($this->getParameter('kernel.environment') === 'dev') {
  333.                         $errorMessage .= ' | Fichier: ' . basename($e->getFile()) . ':' . $e->getLine();
  334.                         if (method_exists($e, 'getErrorData') && $e->getErrorData()) {
  335.                             $errorMessage .= ' | Détails: ' . json_encode($e->getErrorData());
  336.                         }
  337.                     }
  338.                     
  339.                     $this->addFlash('error', $errorMessage);
  340.                     return $this->redirectToRoute('app_orders_show', ['id' => $order->getId()]);
  341.                     
  342.                 } catch (\Exception $e) {
  343.                     $errorDetails = [
  344.                         'message' => $e->getMessage(),
  345.                         'code' => $e->getCode(),
  346.                         'file' => $e->getFile(),
  347.                         'line' => $e->getLine(),
  348.                         'trace' => $e->getTraceAsString()
  349.                     ];
  350.                     
  351.                     $this->logger->error('Airtel Money Exception générique', $errorDetails);
  352.                     
  353.                     $errorMessage = 'Une erreur est survenue lors de l\'initiation du paiement Airtel Money.';
  354.                     if ($this->getParameter('kernel.environment') === 'dev') {
  355.                         $errorMessage .= ' | Erreur: ' . $e->getMessage() . ' | Fichier: ' . basename($e->getFile()) . ':' . $e->getLine();
  356.                     }
  357.                     
  358.                     $this->addFlash('error', $errorMessage);
  359.                     return $this->redirectToRoute('app_orders_show', ['id' => $order->getId()]);
  360.                 }
  361.             } elseif ($data['type'] == 'stripe') {
  362.                 $user = $userRepository->findOneBy(['phone' => $this->getUser()->getUserIdentifier()]);
  363.                 $amountCents = $this->stripePaymentService->convertToCents($total);
  365.                 // Définis les URLs de redirection après paiement
  366.                 $successUrl = $this->generateUrl('app_orders_show', ['id' => $order->getId()], \Symfony\Component\Routing\Generator\UrlGeneratorInterface::ABSOLUTE_URL);
  367.                 $cancelUrl = $this->generateUrl('app_orders_index', [], \Symfony\Component\Routing\Generator\UrlGeneratorInterface::ABSOLUTE_URL);
  369.                 $checkout = $this->stripePaymentService->createCheckoutSession(
  370.                     $amountCents,
  371.                     'usd',
  372.                     $successUrl,
  373.                     $cancelUrl,
  374.                     [
  375.                         'order_id' => $order->getId(),
  376.                         'user_id' => $user->getId()
  377.                     ]
  378.                 );
  380.                 $paiement = new Paiement();
  381.                 $paiement->setOrders($order);
  382.                 $paiement->setType('Stripe');
  383.                 $paiement->setAmount($total);
  384.                 $paiement->setStatus('pending');
  385.                 $paiement->setOmNotifToken('');
  386.                 $paiement->setOmPayToken('');
  387.                 // Tu peux stocker l'ID de session Stripe si tu veux, par exemple :
  388.                 $paiement->setSPaymentIntent($checkout['session_id']); // ou $session->id si tu préfères
  389.                 $entityManager->persist($paiement);
  390.                 $entityManager->flush();
  392.                 // Redirige l'utilisateur vers l'URL de paiement Stripe
  393.                 return $this->redirect($checkout['url']);
  394.             }
  395.             return $this->redirectToRoute('app_orders_index');
  396.         }
  397.         return $this->render('orders/show.html.twig', [
  398.             'order' => $order,
  399.             'form' => $form->createView(),
  401.         ]);
  402.     }
  404.     #[Route('/OM/notif', name: '_notif', methods: ['POST'])]
  405.     public function handleNotification(Request $request, EntityManagerInterface $entityManager): Response
  406.     {
  407.         $data = json_decode($request->getContent(), true);
  409.         if (!isset($data['status'], $data['notif_token'], $data['txnid'])) {
  410.             return $this->json(['error' => 'Invalid payload'], Response::HTTP_BAD_REQUEST);
  411.         }
  413.         /** @var Paiement  */
  414.         $paiement = $entityManager->getRepository(Paiement::class)->findOneBy(['om_notif_token' => $data['notif_token']]);
  416.         if (!$paiement) {
  417.             return $this->json(['error' => 'Payment not found'], Response::HTTP_NOT_FOUND);
  418.         }
  420.         if ($data['status'] === 'SUCCESS') {
  421.             $paiement->setStatus('completed');
  422.             $paiement->getOrders()->setStatus('completed');
  423.         } else {
  424.             $paiement->setStatus('failed');
  425.             $paiement->getOrders()->setStatus('failed');
  426.         }
  428.         $entityManager->flush();
  430.         return $this->json(['message' => 'Notification processed successfully']);
  431.     }
  433.     #[Route('/cancel/{uid}', name: '_cancel')]
  434.     #[IsGranted('ROLE_USER')]
  435.     public function cancelOrder(string $uid, EntityManagerInterface $entityManager): Response
  436.     {
  437.         $order = $entityManager->getRepository(Order::class)->findOneBy(['uid' => $uid]);
  439.         if (!$order || $order->getClient() !== $this->getUser()) {
  440.             $this->addFlash('error', 'Order not found or access denied.');
  441.             return $this->redirectToRoute('app_orders_index');
  442.         }
  444.         if ($order->getStatus() === 'completed') {
  445.             $this->addFlash('error', 'Completed orders cannot be canceled.');
  446.             return $this->redirectToRoute('app_orders_show', ['id' => $order->getId()]);
  447.         }
  449.         $order->setStatus('canceled');
  450.         $entityManager->flush();
  452.         $this->addFlash('success', 'Order has been canceled successfully.');
  453.         return $this->redirectToRoute('app_orders_index');
  454.     }
  457.     #[Route("/api/mvola/callback", methods: ['PUT', 'POST'], name: '_api_mvola_callback')]
  458.     public function handleCallback(Request $request, EntityManagerInterface $entityManager, PaiementRepository $paiementRepository): JsonResponse
  459.     {
  460.         try {
  461.             // Get callback data
  462.             $data = json_decode($request->getContent(), true);
  463.             
  464.             if (!$data) {
  465.                 throw new MVolaApiException('Invalid callback data');
  466.             }
  467.             
  468.             // Validate and process callback data
  469.             $validatedData = $this->mvolaApiService->handleCallback($data);
  470.             
  471.             // Récupérer le serverCorrelationId depuis les données validées
  472.             $serverCorrelationId = $validatedData['serverCorrelationId'] ?? null;
  473.             
  474.             if (!$serverCorrelationId) {
  475.                 throw new MVolaApiException('Missing serverCorrelationId in callback data');
  476.             }
  477.             
  478.             // Trouver le paiement correspondant
  479.             $paiement = $paiementRepository->findOneBy(['CorrelationId' => $serverCorrelationId, 'type' => 'MVola']);
  480.             
  481.             if (!$paiement) {
  482.                 throw new MVolaApiException('Payment not found for serverCorrelationId: ' . $serverCorrelationId);
  483.             }
  484.             
  485.             // Mettre à jour le statut du paiement et de la commande
  486.             $transactionStatus = $validatedData['transactionStatus'] ?? null;
  487.             
  488.             if ($transactionStatus === 'completed') {
  489.                 $paiement->setStatus('completed');
  490.                 $paiement->getOrders()->setStatus('completed');
  491.             } elseif ($transactionStatus === 'failed') {
  492.                 $paiement->setStatus('failed');
  493.                 $paiement->getOrders()->setStatus('failed');
  494.             } else {
  495.                 // Statut inconnu, on garde pending
  496.                 $paiement->setStatus('pending');
  497.             }
  498.             
  499.             $entityManager->flush();
  500.             
  501.             return $this->json([
  502.                 'success' => true,
  503.                 'message' => 'Callback processed successfully',
  504.             ]);
  505.         } catch (MVolaApiException $e) {
  506.             return $this->json([
  507.                 'error' => true,
  508.                 'message' => $e->getMessage(),
  509.             ], Response::HTTP_BAD_REQUEST);
  510.         } catch (\Exception $e) {
  511.             return $this->json([
  512.                 'error' => true,
  513.                 'message' => 'An error occurred while processing the callback.',
  514.             ], Response::HTTP_INTERNAL_SERVER_ERROR);
  515.         }
  516.     }
  518.     #[Route("/api/airtel/callback", methods: ['POST', 'PUT'], name: '_api_airtel_callback')]
  519.     public function handleAirtelCallback(Request $request, EntityManagerInterface $entityManager, PaiementRepository $paiementRepository): JsonResponse
  520.     {
  521.         try {
  522.             // Get callback data
  523.             $data = json_decode($request->getContent(), true);
  524.             
  525.             if (!$data) {
  526.                 throw new AirtelApiException('Invalid callback data');
  527.             }
  528.             
  529.             // Validate and process callback data
  530.             $validatedData = $this->airtelMoney->handleCallback($data);
  531.             
  532.             // Récupérer le transaction_id depuis les données validées
  533.             $transactionId = $validatedData['transaction_id'] ?? null;
  534.             
  535.             if (!$transactionId) {
  536.                 throw new AirtelApiException('Missing transaction_id in callback data');
  537.             }
  538.             
  539.             // Trouver le paiement correspondant
  540.             $paiement = $paiementRepository->findOneBy(['om_pay_token' => $transactionId, 'type' => 'AirtelMoney']);
  541.             
  542.             if (!$paiement) {
  543.                 throw new AirtelApiException('Payment not found for transaction_id: ' . $transactionId);
  544.             }
  545.             
  546.             // Mettre à jour le statut du paiement et de la commande
  547.             $transactionStatus = $validatedData['status'] ?? null;
  548.             
  549.             if ($transactionStatus === 'TS' || $transactionStatus === 'SUCCESS') {
  550.                 $paiement->setStatus('completed');
  551.                 $paiement->getOrders()->setStatus('completed');
  552.             } elseif ($transactionStatus === 'TF' || $transactionStatus === 'FAILED') {
  553.                 $paiement->setStatus('failed');
  554.                 $paiement->getOrders()->setStatus('failed');
  555.             } else {
  556.                 // Statut inconnu, on garde pending
  557.                 $paiement->setStatus('pending');
  558.             }
  559.             
  560.             $entityManager->flush();
  561.             
  562.             return $this->json([
  563.                 'success' => true,
  564.                 'message' => 'Callback processed successfully',
  565.             ]);
  566.         } catch (AirtelApiException $e) {
  567.             return $this->json([
  568.                 'error' => true,
  569.                 'message' => $e->getMessage(),
  570.             ], Response::HTTP_BAD_REQUEST);
  571.         } catch (\Exception $e) {
  572.             return $this->json([
  573.                 'error' => true,
  574.                 'message' => 'An error occurred while processing the callback.',
  575.             ], Response::HTTP_INTERNAL_SERVER_ERROR);
  576.         }
  577.     }
  579.    
  580.     #[Route('/api/mvola/merchant-pay/transaction/{transactionId}', name: 'api_mvola_merchant_pay_transaction_details', methods: ['GET'])]
  581.     public function getTransactionDetails(Request $request, string $transactionId): JsonResponse
  582.     {
  583.         try {
  584.             // Validate API key from request
  585.             $this->validateApiKey($request);
  586.             
  587.             // Call service
  588.             $response = $this->mvolaApiService->getTransactionDetails($transactionId);
  589.             
  590.             return $this->json($response);
  591.         } catch (MVolaApiException $e) {
  592.             return $this->json([
  593.                 'error' => true,
  594.                 'message' => $e->getMessage(),
  595.                 'details' => $e->getErrorData(),
  596.             ], Response::HTTP_BAD_REQUEST);
  597.         } catch (\Exception $e) {
  598.             return $this->json([
  599.                 'error' => true,
  600.                 'message' => 'An error occurred while processing your request.',
  601.             ], Response::HTTP_INTERNAL_SERVER_ERROR);
  602.         }
  603.     }
  605.     #[Route('/api/mvola/merchant-pay/status/{serverCorrelationId}', name: 'api_mvola_merchant_pay_transaction_status', methods: ['GET'])]
  606.     public function getTransactionStatus(Request $request, string $serverCorrelationId): JsonResponse
  607.     {
  608.         try {
  609.             // Validate API key from request
  610.             $this->validateApiKey($request);
  611.             
  612.             // Call service
  613.             $response = $this->mvolaApiService->getTransactionStatus($serverCorrelationId);
  614.             
  615.             return $this->json($response);
  616.         } catch (MVolaApiException $e) {
  617.             return $this->json([
  618.                 'error' => true,
  619.                 'message' => $e->getMessage(),
  620.                 'details' => $e->getErrorData(),
  621.             ], Response::HTTP_BAD_REQUEST);
  622.         } catch (\Exception $e) {
  623.             return $this->json([
  624.                 'error' => true,
  625.                 'message' => 'An error occurred while processing your request.',
  626.             ], Response::HTTP_INTERNAL_SERVER_ERROR);
  627.         }
  628.     }
  631.     /**
  632.      * Validate API key from request
  633.      * 
  634.      * @param Request $request
  635.      * @throws MVolaApiException If API key is invalid
  636.      */
  637.     private function validateApiKey(Request $request): void
  638.     {
  639.         $apiKey = $request->headers->get('X-API-Key');
  640.         $expectedApiKey = $this->getParameter('app.api_key');
  641.         
  642.         if (!$apiKey || $apiKey !== $expectedApiKey) {
  643.             throw new MVolaApiException('Invalid or missing API key', Response::HTTP_UNAUTHORIZED);
  644.         }
  645.     }
  648.     #[Route('/stripe/webhook', name: 'stripe_webhook', methods: ['POST'])]
  649.     public function handleWebhook(Request $request,StripePaymentService $stripePaymentService,PaiementRepository $paiementRepository,EntityManagerInterface $entityManager): JsonResponse
  650.     {
  651.         try {
  652.             $result = $stripePaymentService->handleWebhook($request);
  654.             if ($result['event_type'] === 'payment_intent.succeeded') {
  655.                 $paymentIntentId = $result['event_id'];
  656.                 $paiement = $paiementRepository->findOneBy(['SPaymentIntent' => $paymentIntentId]);
  657.                 if ($paiement) {
  658.                     $paiement->setStatus('paid');
  659.                     $entityManager->flush();
  660.                 }
  661.             }
  662.             if ($result['event_type'] === 'payment_intent.canceled') {
  663.                 $paymentIntentId = $result['event_id'];
  664.                 $paiement = $paiementRepository->findOneBy(['SPaymentIntent' => $paymentIntentId]);
  665.                 if ($paiement) {
  666.                     $paiement->setStatus('canceled');
  667.                     $entityManager->flush();
  668.                 }
  669.             }
  671.             if ($result['event_type'] === 'payment_intent.failed') {
  672.                 $paymentIntentId = $result['event_id'];
  673.                 $paiement = $paiementRepository->findOneBy(['SPaymentIntent' => $paymentIntentId]);
  674.                 if ($paiement) {
  675.                     $paiement->setStatus('failed');
  676.                     $entityManager->flush();
  677.                 }
  678.             }
  679.             return $this->json($result);
  681.         } catch (\Exception $e) {
  682.             return $this->json([
  683.                 'error' => 'Webhook processing failed',
  684.                 'message' => $e->getMessage()
  685.             ], 400);
  686.         }
  687.     }
  688. }