Procéder à la réalisation suite aux paiements par Checkout et Payment Link

Créez une fonction sur votre serveur pour réaliser les commandes associées aux paiements Checkout. Les webhooks déclenchent cette fonction, qui est appelée lorsque les clients sont renvoyés sur votre site Web après avoir effectué le paiement Checkout. 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 identifiant de Session Checkout comme argument.
3. récupérer la session Checkout de l’API avec la propriété line_itemsétendue.
4. vérifiez la propriété payment_status pour déterminer si la commande doit être réalisée.
5. effectuer le traitement des postes de facture.
6. enregistrer l’état d’exécution 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_4eC39HqLyjWDarjtT1zdp7dc'

  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
  # peformed 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 peformed
  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 entreprise, vous pouvez demander à votre fonction fulfill_checkout d’effectuer les opérations suivantes :

• Fournir un accès aux services.
• Déclencher l’expédition de marchandises.
• Enregistrez une copie des détails du paiement et des postes individuels dans votre propre base de données.
• Envoyez au client un reçu personnalisé par e-mail si vous n’avez pas activé les reçus de Stripe.
• Rapprochez les postes et les quantités achetées si vous permettez aux clients d’ajuster les quantités dans Checkout.
• Actualisez les registres d’inventaire ou de stock.

Pour déclencher l’a réalisation, créez un gestionnaire d’événements webhook pour écouter les événements de paiement et déclencher votre fonction fulfill_checkout.

Lorsque quelqu’un vous paie avec Checkout, 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.

Certains moyens de paiement ne sont pas instantanés, comme les prélèvements automatiques ACH et autres virements bancaires. Les fonds ne seront pas immédiatement disponibles à la fin du processus Checkout. Les moyens de paiement différé génèrent un événement checkout.session.async_payment_succeeded lorsque le paiement est effectué ultérieurement.

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é.

La manière la plus rapide de développer et de tester votre gestionnaire d’événement webhook est d’utiliser le CLI Stripe. Si vous ne l’avez pas, suivez le guide d’installation pour commencer.

Lorsque le CLI Stripe est installé, 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 le CLI 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 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

Lorsque le paiement est terminé, vérifiez les points suivants :

• Sur votre ligne de commande, où stripe listen est en cours d’exécution, il montre un événement checkout.session.completed transmis à votre serveur local.
• Les journaux de votre serveur montrent 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. Ajoutez le paramètre substituable {CHECKOUT_SESSION_ID} dans l’URL de votre page, qui sera remplacé par l’identifiant de la session Checkout lorsque votre client est redirigé à partir de Checkout.

Checkout hébergé

Pour les sessions Checkout dont le code ui_mode par défaut est hosted, définissez le success_url.

curl https://api.stripe.com/v1/checkout/sessions \
  -u "
sk_test_4eC39HqLyjWDarjtT1zdp7dc
:" \
  -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}"

Checkout avec un ui_mode différent du code par défaut

Pour les sessions Checkout dont le code ui_mode n’est pas défini sur hosted, définissez le return_url.

curl https://api.stripe.com/v1/checkout/sessions \
  -u "
sk_test_4eC39HqLyjWDarjtT1zdp7dc
:" \
  -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}"

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_4eC39HqLyjWDarjtT1zdp7dc
:" \
  -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 d’accueil qui inclut le paramètre substituable {CHECKOUT_SESSION_ID} (par exemple, 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 la réalisation pour chaque paiement, mais les webhooks peuvent parfois être retardés. Pour optimiser votre tunnel de paiement et garantir une réalisation immédiate lorsque votre client est présent, déclenchez également la réalisation à partir de 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 réalisation terminée.

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

• Détails du processus de réalisation de la commande.
• 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.