src/Services/StripePaymentService.php line 273

  1. <?php
  3. namespace App\Services;
  5. use Stripe\Stripe;
  6. use Stripe\PaymentIntent;
  7. use Stripe\Customer;
  8. use Stripe\Webhook;
  9. use Stripe\Exception\SignatureVerificationException;
  10. use Psr\Log\LoggerInterface;
  11. use Symfony\Component\HttpFoundation\Request;
  12. use Stripe\Checkout\Session as StripeSession;
  14. class StripePaymentService
  15. {
  16.     private LoggerInterface $logger;
  17.     private string $stripeSecretKey;
  18.     private string $webhookSecret;
  20.     public function __construct(
  21.         LoggerInterface $logger,
  22.         string $stripeSecretKey,
  23.         string $webhookSecret
  24.     ) {
  25.         $this->logger = $logger;
  26.         $this->stripeSecretKey = $stripeSecretKey;
  27.         $this->webhookSecret = $webhookSecret;
  28.         
  29.         Stripe::setApiKey($this->stripeSecretKey);
  30.     }
  32.     /**
  33.      * Create a payment intent
  34.      */
  35.     public function createPaymentIntent(
  36.         int $amount,
  37.         string $currency = 'usd',
  38.         ?string $customerId = null,
  39.         array $metadata = []
  40.     ): PaymentIntent {
  41.         try {
  42.             $params = [
  43.                 'amount' => $amount, // Amount in cents
  44.                 'currency' => $currency,
  45.                 'automatic_payment_methods' => [
  46.                     'enabled' => true,
  47.                 ],
  48.                 'metadata' => $metadata,
  49.             ];
  51.             if ($customerId) {
  52.                 $params['customer'] = $customerId;
  53.             }
  55.             $paymentIntent = PaymentIntent::create($params);
  56.             
  57.             $this->logger->info('Payment intent created', [
  58.                 'payment_intent_id' => $paymentIntent->id,
  59.                 'amount' => $amount,
  60.                 'currency' => $currency,
  61.                 'customer_id' => $customerId
  62.             ]);
  64.             return $paymentIntent;
  65.         } catch (\Exception $e) {
  66.             $this->logger->error('Failed to create payment intent', [
  67.                 'error' => $e->getMessage(),
  68.                 'amount' => $amount,
  69.                 'currency' => $currency
  70.             ]);
  71.             throw $e;
  72.         }
  73.     }
  75.     /**
  76.      * Confirm a payment intent
  77.      */
  78.     public function confirmPaymentIntent(string $paymentIntentId, string $paymentMethodId): PaymentIntent
  79.     {
  80.         try {
  81.             $paymentIntent = PaymentIntent::retrieve($paymentIntentId);
  82.             $paymentIntent = $paymentIntent->confirm([
  83.                 'payment_method' => $paymentMethodId,
  84.             ]);
  86.             $this->logger->info('Payment intent confirmed', [
  87.                 'payment_intent_id' => $paymentIntentId,
  88.                 'status' => $paymentIntent->status
  89.             ]);
  91.             return $paymentIntent;
  92.         } catch (\Exception $e) {
  93.             $this->logger->error('Failed to confirm payment intent', [
  94.                 'payment_intent_id' => $paymentIntentId,
  95.                 'error' => $e->getMessage()
  96.             ]);
  97.             throw $e;
  98.         }
  99.     }
  101.     /**
  102.      * Create or retrieve a Stripe customer
  103.      */
  104.     public function createCustomer(string $email, string $name = '', array $metadata = []): Customer
  105.     {
  106.         try {
  107.             $customer = Customer::create([
  108.                 'email' => $email,
  109.                 'name' => $name,
  110.                 'metadata' => $metadata,
  111.             ]);
  113.             $this->logger->info('Customer created', [
  114.                 'customer_id' => $customer->id,
  115.                 'email' => $email
  116.             ]);
  118.             return $customer;
  119.         } catch (\Exception $e) {
  120.             $this->logger->error('Failed to create customer', [
  121.                 'email' => $email,
  122.                 'error' => $e->getMessage()
  123.             ]);
  124.             throw $e;
  125.         }
  126.     }
  128.     /**
  129.      * Retrieve a payment intent
  130.      */
  131.     public function getPaymentIntent(string $paymentIntentId): PaymentIntent
  132.     {
  133.         try {
  134.             return PaymentIntent::retrieve($paymentIntentId);
  135.         } catch (\Exception $e) {
  136.             $this->logger->error('Failed to retrieve payment intent', [
  137.                 'payment_intent_id' => $paymentIntentId,
  138.                 'error' => $e->getMessage()
  139.             ]);
  140.             throw $e;
  141.         }
  142.     }
  144.     /**
  145.      * Cancel a payment intent
  146.      */
  147.     public function cancelPaymentIntent(string $paymentIntentId): PaymentIntent
  148.     {
  149.         try {
  150.             $paymentIntent = PaymentIntent::retrieve($paymentIntentId);
  151.             $paymentIntent = $paymentIntent->cancel();
  153.             $this->logger->info('Payment intent cancelled', [
  154.                 'payment_intent_id' => $paymentIntentId
  155.             ]);
  157.             return $paymentIntent;
  158.         } catch (\Exception $e) {
  159.             $this->logger->error('Failed to cancel payment intent', [
  160.                 'payment_intent_id' => $paymentIntentId,
  161.                 'error' => $e->getMessage()
  162.             ]);
  163.             throw $e;
  164.         }
  165.     }
  167.     /**
  168.      * Handle Stripe webhooks
  169.      */
  170.     public function handleWebhook(Request $request): array
  171.     {
  172.         $payload = $request->getContent();
  173.         $sigHeader = $request->headers->get('stripe-signature');
  175.         try {
  176.             $event = Webhook::constructEvent($payload, $sigHeader, $this->webhookSecret);
  177.         } catch (\UnexpectedValueException $e) {
  178.             $this->logger->error('Invalid webhook payload', ['error' => $e->getMessage()]);
  179.             throw $e;
  180.         } catch (SignatureVerificationException $e) {
  181.             $this->logger->error('Invalid webhook signature', ['error' => $e->getMessage()]);
  182.             throw $e;
  183.         }
  185.         $this->logger->info('Webhook received', [
  186.             'event_type' => $event['type'],
  187.             'event_id' => $event['id']
  188.         ]);
  190.         // Handle the event
  191.         switch ($event['type']) {
  192.             case 'payment_intent.succeeded':
  193.                 $this->handlePaymentSucceeded($event['data']['object']);
  194.                 break;
  195.             case 'payment_intent.payment_failed':
  196.                 $this->handlePaymentFailed($event['data']['object']);
  197.                 break;
  198.             case 'payment_intent.canceled':
  199.                 $this->handlePaymentCanceled($event['data']['object']);
  200.                 break;
  201.             default:
  202.                 $this->logger->info('Unhandled webhook event type', ['event_type' => $event['type']]);
  203.         }
  205.         return [
  206.             'event_type' => $event['type'],
  207.             'event_id' => $event['id'],
  208.             'processed' => true
  209.         ];
  210.     }
  212.     /**
  213.      * Handle successful payment
  214.      */
  215.     private function handlePaymentSucceeded($paymentIntent): void
  216.     {
  217.         $this->logger->info('Payment succeeded', [
  218.             'payment_intent_id' => $paymentIntent['id'],
  219.             'amount' => $paymentIntent['amount'],
  220.             'currency' => $paymentIntent['currency']
  221.         ]);
  223.         // Add your business logic here
  224.         // For example: update order status, send confirmation email, etc.
  225.     }
  227.     /**
  228.      * Handle failed payment
  229.      */
  230.     private function handlePaymentFailed($paymentIntent): void
  231.     {
  232.         $this->logger->warning('Payment failed', [
  233.             'payment_intent_id' => $paymentIntent['id'],
  234.             'amount' => $paymentIntent['amount'],
  235.             'currency' => $paymentIntent['currency'],
  236.             'last_payment_error' => $paymentIntent['last_payment_error'] ?? null
  237.         ]);
  239.         // Add your business logic here
  240.         // For example: notify user, update order status, etc.
  241.     }
  243.     /**
  244.      * Handle canceled payment
  245.      */
  246.     private function handlePaymentCanceled($paymentIntent): void
  247.     {
  248.         $this->logger->info('Payment canceled', [
  249.             'payment_intent_id' => $paymentIntent['id'],
  250.             'amount' => $paymentIntent['amount'],
  251.             'currency' => $paymentIntent['currency']
  252.         ]);
  254.         // Add your business logic here
  255.     }
  257.     /**
  258.      * Convert amount to cents (Stripe expects amounts in cents)
  259.      */
  260.     public function convertToCents(float $amount): int
  261.     {
  262.         return (int) round($amount * 100);
  263.     }
  265.     /**
  266.      * Convert amount from cents to dollars
  267.      */
  268.     public function convertFromCents(int $amount): float
  269.     {
  270.         return $amount / 100;
  271.     }
  273.     public function createCheckoutSession(
  274.         int $amount,
  275.         string $currency = 'usd',
  276.         string $successUrl,
  277.         string $cancelUrl,
  278.         array $metadata = []
  279.     ): array {
  280.         try {
  281.             $session = StripeSession::create([
  282.                 'payment_method_types' => ['card'],
  283.                 'line_items' => [[
  284.                     'price_data' => [
  285.                         'currency' => $currency,
  286.                         'product_data' => [
  287.                             'name' => 'Paiement',
  288.                         ],
  289.                         'unit_amount' => $amount,
  290.                     ],
  291.                     'quantity' => 1,
  292.                 ]],
  293.                 'mode' => 'payment',
  294.                 'success_url' => $successUrl,
  295.                 'cancel_url' => $cancelUrl,
  296.                 'metadata' => $metadata,
  297.             ]);
  298.             $this->logger->info('Checkout session créée', [
  299.                 'session_id' => $session->id,
  300.                 'url' => $session->url,
  301.             ]);
  302.         return [  'url' =>  $session->url,
  303.             'session_id' => $session->id,
  304.         ];
  305.         } catch (\Exception $e) {
  306.             $this->logger->error('Erreur création session checkout', [
  307.                 'error' => $e->getMessage(),
  308.             ]);
  309.             throw $e;
  310.         }
  311.     }
  312. }