Traiter vos commandes

Créez une fonction sur votre serveur pour lancer le traitement lorsque les paiements sont effectués. Les webhooks déclencheront cette fonction, qui sera appelée lorsque les clients seront renvoyés vers 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érez correctement le fait d’être appelé plusieurs fois avec le même ID de session Checkout.
2. Acceptez un ID de session Session en tant qu’argument.
3. Récupérez la session Checkout à partir de l’API à l’aide de la propriété line_items étendue.
4. Vérifiez la propriété payment_status pour déterminer si elle doit être traitée.
5. Effectuer le traitement des postes de facture.
6. Enregistrez l’état de traitement de 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 mettre en œuvre.

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.
• Enregistrez une copie des informations de paiement et des postes de facture dans votre propre base de données.
• Envoyer à votre client un reçu personnalisé par courriel si vous n’avez pas activé les reçus de Stripe.
• Rapprochez les postes de facture 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 point de terminaison sur votre serveur pour accepter, traiter et confirmer la réception de ces événements.

Modes de paiement immédiat et modes de paiement différé

Certains modes de paiement ne sont pas instantanés, comme les ACH Direct Debit et d’autres virements bancaires. Cela signifie que les fonds ne seront pas immédiatement disponibles à la fin du processus Checkout. Les modes de paiement différé génèrent un événement checkout.session.async_payment_succeeded lorsque le paiement est effectué ultérieurement. L’état de l’objet est en cours de traitement jusqu’à ce que l’état du paiement réussisse ou échoue.

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 courriel à 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 l’interface de ligne de commande Stripe. Si vous ne disposez pas de l’interface de ligne de commande Stripe, consultez le guide d’installation pour commencer.

Lorsque l’interface de ligne de commande 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 l’interface de ligne de commande Stripe 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 la clé secrète du webhook (whsec_...) à votre code de gestion des événements, puis testez le traitement en passant par Checkout en tant que client :

• Appuyez sur le bouton de paiement qui vous permet d’accéder à Checkout ou accédez à votre lien de paiement
• Fournissez les données de test suivantes dans Checkout :
  • Saisissez 4242 4242 4242 4242 comme numéro de carte
  • Saisissez une date future pour l’expiration de la carte
  • 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, lorsque stripe listen est en cours d’exécution, il est indiqué qu’un événement checkout.session.completed a été transmis à votre serveur local.
• Les journaux de votre serveur affichent la sortie attendue de votre fonction fulfill_checkout.

Après avoir effectué des tests localement, faites en sorte que votre gestionnaire d’événements de liens de rappel soit opérationnel sur votre serveur. Ensuite, créez un point de terminaison de lien de rappel pour envoyer des événements checkout.session.completed à votre serveur, puis testez à nouveau le flux de paiement.

Configurez Checkout pour rediriger votre client vers une page de votre site Web une fois qu’il a terminé le paiement. Ajoutez l’espace réservé {CHECKOUT_SESSION_ID} à l’URL de votre page, qui sera remplacé par l’ID de session Checkout lorsque votre client est redirigé à partir de Checkout.

Checkout hébergé

Pour les sessions Checkout dont l’ui_mode par défaut est hosted, définissez le paramètresuccess_url.

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 \
  --data-urlencode success_url="https://example.com/after-checkout?session_id={CHECKOUT_SESSION_ID}"

Payment Links

Pour les Payment Links que vous créez avec l’API, définissez le paramètre after_completion.redirect.url.

curl https://api.stripe.com/v1/payment_links \
  -u "
sk_test_BQokikJOvBiI2HlWgH4olfQ2
:" \
  -d "line_items[0][price]"=
{{PRICE_ID}} \
  -d "line_items[0][quantity]"=1 \
  -d "after_completion[type]"=redirect \
  --data-urlencode "after_completion[redirect][url]"="https://example.com/after-checkout?session_id={CHECKOUT_SESSION_ID}"

Pour les Payment Links que vous créez dans le Dashboard :

1. Accédez à l’onglet Après le paiement.
2. Sélectionnez Ne pas afficher la page de confirmation.
3. Fournissez l’URL de votre page de renvoi qui inclut le paramètre réservé{CHECKOUT_SESSION_ID} (par exemple, https://example.com/after-checkout?session_id={CHECKOUT_SESSION_ID})

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

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 de renvoi Checkout, vous devez extraire l’ID 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.
• Informations sur la livraison ou la logistique des marchandises physiques.