Traiter les commandes

Créez une fonction sur votre serveur pour initier le traitement une fois les paiements effectués. Les webhooks en place déclencheront cette fonction, qui sera appelée lorsque les clients seront renvoyés sur votre site Web après avoir effectué le paiement. Ce guide fait référence à cette fonction sous le nom de fulfill_checkout, mais vous pouvez lui donner un autre nom.

Votre fonction fulfill_checkout doit :

1. Gérer correctement le fait d’être appelée plusieurs fois avec le même identifiant de session Checkout.
2. Accepter un ID de Session Checkout comme argument.
3. Récupérer la session Checkout depuis l’API avec la propriété line_items étendue.
4. Vérifier la propriété payment_status pour déterminer si le traitement doit être déclenché.
5. Lancer le traitement des postes de facture.
6. Enregistrer l’état du traitement pour la session Checkout fournie.

Utilisez le code ci-dessous comme point de départ pour votre fonction fulfill_checkout. Les commentaires TODO indiquent les fonctionnalités que vous devez implémenter.

def fulfill_checkout(session_id)
  # Set your secret key. Remember to switch to your live secret key in production.
  # See your keys here: https://dashboard.stripe.com/apikeys
  Stripe.api_key = 
'sk_test_BQokikJOvBiI2HlWgH4olfQ2'

  puts "Fullfilling Checkout Session #{session_id}"

  # TODO: Make this function safe to run multiple times,
  # even concurrently, with the same session ID

  # TODO: Make sure fulfillment hasn't already been
  # performed for this Checkout Session

  # Retrieve the Checkout Session from the API with line_items expanded
  checkout_session = Stripe::Checkout::Session.retrieve({
    id: session_id,
    expand: ['line_items'],
  })

  # Check the Checkout Session's payment_status property
  # to determine if fulfillment should be performed
  if checkout_session.payment_status != 'unpaid'
    # TODO: Perform fulfillment of the line items

    # TODO: Record/save fulfillment status for this
    # Checkout Session
  end
end

En fonction des moyens de paiement que vous acceptez et des besoins de votre activité, vous pouvez demander à votre fonction fulfill_checkout d’effectuer les opérations suivantes :

• Fournir l’accès aux services.
• Déclencher l’envoi des marchandises.
• Enregistrer une copie des détails du paiement et des postes de la commande dans votre base de données.
• Envoyer à votre client un reçu personnalisé par e-mail si vous n’avez pas activé les reçus de Stripe.
• Rapprocher les postes et les quantités achetées si vous autorisez les clients à ajuster les quantités dans Checkout.
• Actualiser les registres d’inventaire ou de stock.

Pour déclencher le traitement, créez un gestionnaire d’événements webhook pour écouter les événements de paiement et lancer votre fonction fulfill_checkout.

Lorsqu’un règlement est effectué, un événement checkout.session.completed est créé. Configurez un endpoint sur votre serveur pour accepter, traiter et confirmer la réception de ces événements.

Immediate versus delayed payment methods

Some payment methods aren’t instant, such as ACH direct debit and other bank transfers. This means, funds won’t be immediately available when Checkout completes. Delayed payment methods generate a checkout.session.async_payment_succeeded event when payment succeeds later. The status of the object is in processing until the payment status either succeeds or fails.

require 'sinatra'

# Use the secret provided by Stripe CLI for local testing
# or your webhook endpoint's secret.
endpoint_secret = 'whsec_...'

post '/webhook' do
  event = nil

  # Verify webhook signature and extract the event
  # See https://stripe.com/docs/webhooks#verify-events for more information.
  begin
    sig_header = request.env['HTTP_STRIPE_SIGNATURE']
    payload = request.body.read
    event = Stripe::Webhook.construct_event(payload, sig_header, endpoint_secret)
  rescue JSON::ParserError => e
    # Invalid payload
    return status 400
  rescue Stripe::SignatureVerificationError => e
    # Invalid signature
    return status 400
  end

  if event['type'] == 'checkout.session.completed' ||
  event['type'] == 'checkout.session.async_payment_succeeded'
    fulfill_checkout(event['data']['object']['id'])
  end

  status 200
end

Vous pouvez également vouloir écouter et gérer les événements checkout.session.async_payment_failed. Par exemple, vous pouvez envoyer un e-mail à votre client en cas d’échec d’un paiement différé.

Le moyen le plus rapide de développer et de tester votre gestionnaire d’événements webhook est d’utiliser la CLI Stripe. Si vous n’en disposez pas, reportez-vous aux instructions du guide d’installation.

Lorsque la CLI Stripe est installée, vous pouvez tester votre gestionnaire d’événements localement. Lancez votre serveur (par exemple, sur localhost:4242), puis exécutez la commande stripe listen pour que la CLI transmette les événements à votre serveur local :

stripe listen --forward-to localhost:4242/webhook

Ready! Your webhook signing secret is 'whsec_<REDACTED>' (^C to quit)

Ajoutez le secret du webhook (whsec_...) à votre code de gestion des événements, puis testez la réalisation en utilisant Checkout en tant que client :

• Appuyez sur le bouton de paiement qui vous permet de passer à Checkout, ou visitez votre Payment Link
• Fournissez les données de test suivantes dans Checkout :
  • Saisissez 4242 4242 4242 4242 comme numéro de carte bancaire
  • Saisissez n’importe quelle date future comme date d’expiration
  • Saisissez n’importe quel code CVC à 3 chiffres
  • Saisissez un code postal pour la facturation (90210)
• Appuyez sur le bouton Payer

Une fois le paiement effectué, vérifiez les points suivants :

• Sur votre ligne de commande, où stripe listen s’exécute, vous voyez un événement checkout.session.completed transmis à votre serveur local.
• Les logs de votre serveur affichent la sortie attendue de votre fonction fulfill_checkout.

Après avoir testé localement, lancez votre gestionnaire d’événements webhook sur votre serveur. Ensuite, créez un endpoint de webhook pour envoyer les événements checkout.session.completed à votre serveur, puis testez à nouveau le tunnel de paiement Checkout.

Configurez Checkout de manière à ce que le client soit redirigé vers une page de votre site Web une fois qu’il a terminé le processus Checkout. Incluez le paramètre substituable {CHECKOUT_SESSION_ID} dans l’URL de votre page, qui est remplacé par l’ID de session Checkout lorsque votre client termine le processus de paiement.

curl https://api.stripe.com/v1/checkout/sessions \
  -u "
sk_test_BQokikJOvBiI2HlWgH4olfQ2
:" \
  -d "line_items[0][price]"=
{{PRICE_ID}} \
  -d "line_items[0][quantity]"=1 \
  -d mode=payment \
  -d ui_mode=embedded \
  --data-urlencode return_url="https://example.com/after-checkout?session_id={CHECKOUT_SESSION_ID}"

L’écoute des webhooks est nécessaire pour s’assurer que vous déclenchez toujours le traitement pour chaque paiement, mais les webhooks peuvent parfois être retardés. Pour optimiser votre tunnel de paiement et garantir un traitement immédiat lorsque votre client est présent, déclenchez également le traitement depuis votre page d’accueil.

Utilisez l’identifiant de la session Checkout de l’URL indiquée à l’étape précédente pour effectuer les opérations suivantes :

1. Lorsque votre serveur reçoit une requête pour votre page d’accueil Checkout, extrayez l’identifiant de session Checkout de l’URL.
2. Exécutez votre fonction fulfill_checkout avec l’identifiant fourni.
3. Affichez la page une fois la tentative de traitement terminée.

Lorsque vous affichez votre page d’accueil, vous pouvez présenter les éléments suivants :

• Détails du processus de traitement.
• Liens ou informations sur les services auxquels le client a désormais accès.
• Détails relatifs à l’expédition ou à la logistique des biens physiques.