Mengintegrasikan Stripe Menjadi Kedai Django Python Satu Produk

Dalam bahagian pertama siri ini, kami mencipta kedai dalam talian Django dengan htmx.

Dalam bahagian kedua ini, kami akan mengendalikan pesanan menggunakan Stripe.

Apa yang Kami Akan Lakukan

Kami akan menyepadukan Stripe untuk mengendalikan pembayaran dengan selamat. Inilah yang kami mahu capai:

1. Dalam paparan pembelian, kami mulakan dengan membuat sesi pembayaran Stripe dan mengubah hala pelanggan ke URL yang sepadan. Di sinilah kami memberitahu Stripe tentang produk yang kami jual, kuantitinya dan tempat pelanggan harus diubah hala selepas pembelian yang berjaya (url_kejayaan).
2. Pelanggan mengisi butiran pembayaran mereka pada halaman daftar keluar Stripe dan menyelesaikan pembayaran. Stripe kemudiannya membuat permintaan POST ke titik akhir webhook di tapak web kami, tempat kami mendengar acara dan memprosesnya dengan sewajarnya. Jika pembayaran berjaya, kami menyimpan pesanan dalam pangkalan data kami dan memberitahu pelanggan (dan pengguna kakitangan kami) tentang pembelian.
3. Akhir sekali, jika webhook mengembalikan respons dengan kod status HTTP 200 OK, Stripe mengubah hala ke success_url yang dibuat pada langkah pertama.

Menyediakan Stripe untuk Kedai Django Python Kami

Kami mula-mula perlu melompat ke Stripe dan melakukan perkara berikut:

1. Buat akaun Stripe.
2. Buat produk (dengan id pembayaran).
3. Buat webhook.

1: Buat Akaun Stripe

Mulakan dengan membuat akaun Stripe. Buat masa ini, anda tidak perlu mengaktifkan akaun anda. Anda hanya boleh bekerja dalam mod ujian, yang akan menghalang anda daripada membuat pembayaran sebenar semasa menguji. Pergi ke halaman kunci API dan dapatkan semula kunci yang boleh diterbitkan dan rahsia. Simpannya dalam pembolehubah persekitaran projek anda (STRIPE_PUBLISHABLE_KEY dan STRIPE_SECRET_KEY). Kami akan menggunakan kekunci ini untuk mengesahkan permintaan Stripe anda.

2: Cipta Produk Anda

Buat produk baharu pada halaman produk. Isikan butiran dan tetapkan jenis pembayaran kepada sekali sahaja. Produk anda sepatutnya kelihatan seperti ini:

Sebaik sahaja anda menekan Tambah produk, anda sepatutnya dapat melihat produk anda pada senarai produk. Jika anda mengklik padanya dan tatal ke bawah ke bahagian Harga, anda boleh menemui ID API untuk item harga yang anda buat — ia sepatutnya seperti price_3ODP5…. Simpannya dalam pembolehubah persekitaran (STRIPE_PRICE_ID): anda memerlukan ini semasa membuat sesi pembayaran Stripe.

3: Cipta Webhook

Kami perlu membuat titik akhir webhook untuk dihubungi oleh Stripe apabila pembayaran selesai. Dalam halaman webhooks, pilih untuk menguji dalam persekitaran setempat. Ini akan membolehkan anda memajukan permintaan ke URL tempatan, seperti http://127.0.0.1:8000. Mulakan dengan memuat turun Stripe CLI. Kemudian, anda boleh:

1. Log masuk ke Stripe

stripe login

1. Majukan acara ke titik akhir webhook yang akan anda buat:

stripe listen --forward-to http://127.0.0.1:8000/webhook
> Ready! Your webhook signing secret is whsec_06531a7ba22363ac038f284ac547906b89e5c939f8d55dfd03a3619f9adc590a (^C to quit)

Ini memastikan bahawa setelah pembelian dibuat, Stripe memajukan panggilan webhook ke titik akhir setempat anda. Perintah itu akan log rahsia menandatangani webhook, yang anda juga harus simpan sebagai pembolehubah persekitaran projek (STRIPE_WEBHOOK_SECRET). Ini terbukti berguna untuk mengesahkan bahawa permintaan memang datang daripada Stripe dan bahawa anda mengendalikan webhook yang betul.

Pada penghujung bahagian ini, anda sepatutnya mempunyai empat pembolehubah persekitaran Stripe. Anda kini boleh memuatkannya dalam ecommerce_site/settings.py:

# ecommerce_site/settings.py

import os
from dotenv import load_dotenv
load_dotenv()

STRIPE_PUBLISHABLE_KEY = os.environ.get("STRIPE_PUBLISHABLE_KEY")
STRIPE_SECRET_KEY = os.environ.get("STRIPE_SECRET_KEY")
STRIPE_PRICE_ID = os.environ.get("STRIPE_PRICE_ID")
STRIPE_WEBHOOK_SECRET = os.environ.get("STRIPE_WEBHOOK_SECRET")

Nota: Kami menggunakan python-dotenv untuk memuatkan pembolehubah persekitaran.

Panjangkan Pandangan

Kini kami perlu meluaskan pandangan untuk menyepadukan Stripe dengan membuat sesi pembayaran, paparan pembelian yang berjaya dan paparan webhook.

1: Buat Sesi Checkout Stripe

Dalam paparan pembelian, kami akan membuat sesi pembayaran Stripe jika borang pembelian adalah sah:

# ecommerce/views.py
from django_htmx import HttpResponseClientRedirect
from django.conf import settings
import stripe

@require_POST
def purchase(request):
    form = OrderForm(request.POST)
    if form.is_valid():
        quantity = form.cleaned_data["quantity"]

        # replace time.sleep(2) with the following code ⬇️

        # 1 - set stripe api key
        stripe.api_key = settings.STRIPE_SECRET_KEY

        # 2 - create success url
        success_url = (
            request.build_absolute_uri(
                reverse("purchase_success")
            )
            + "?session_id={CHECKOUT_SESSION_ID}"
        )

        # 3 - create cancel url
        cancel_url = request.build_absolute_uri(reverse("home"))

        # 4 - create checkout session
        checkout_session = stripe.checkout.Session.create(
            line_items=[
                {
                    "price": settings.STRIPE_PRICE_ID,
                    "quantity": quantity,
                }
            ],
            mode="payment",
            success_url=success_url,
            cancel_url=cancel_url
        )

        # 5 - redirect to checkout session url
        return HttpResponseClientRedirect(checkout_session.url)
    return render(request, "product.html", {"form": form})

Mari pecahkan perkara ini:

1. We first set the Stripe API key.
2. We then create a successful purchase URL pointing to the purchase_success view (which we'll create in the next step). Stripe should automatically populate the CHECKOUT_SESSION_ID.
3. We create a URL for when a purchase is canceled — for example, when the customer changes their mind. In this case, it’s just the home view.
4. We create a Stripe checkout session with our price ID (the product identifier) and the quantity the customer wants to purchase.
5. Stripe returns a session object from which we can extract the URL and redirect the customer. Since this request is coming from htmx, we can’t really use the standard Django redirect function. Instead, we use the django-htmx package, which provides this HttpResponseClientRedirect class.

2: Create the Successful Purchase View

After completing the purchase, Stripe will redirect the customer to our specified success_url. Here, we can handle the post-purchase logic:

from django.shortcuts import redirect

def purchase_success(request):
    session_id = request.GET.get("session_id")
    if session_id is None:
          return redirect("home")

    stripe.api_key = settings.STRIPE_SECRET_KEY
    try:
        stripe.checkout.Session.retrieve(session_id)
    except stripe.error.InvalidRequestError:
        messages.error(request, "There was a problem while buying your product. Please try again.")
        return redirect("home")
    return render(request, "purchase_success.html")

In this view, we first check if the session_id query parameter is present. If it is, we retrieve the corresponding session from Stripe using the secret key and the session_id. We then render the successful purchase template, which looks like this:

# ecommerce/templates/purchase_success.html {% extends "base.html" %} {% block
content %}
<section>
  <header>
    <h2>Thank you for your purchase</h2>
    <p>
      Your purchase was successful. You will receive an email with the details
      of your purchase soon.
    </p>
  </header>
</section>
{% endblock %}

You should also add it to the urlpatterns:

# ecommerce_site/urls.py

# ... same imports as before

urlpatterns = [
    # ... same urls as before
    path("purchase_success", views.purchase_success, name="purchase_success"),  # ⬅️ new
]

3: Create the Webhook View

While the customer is in the purchase process, and before they are redirected to the success view, Stripe will call our webhook endpoint (remember to have the webhook listener running, as explained in the earlier 'Create the Webhook' section of this post):

from django.views.decorators.csrf import csrf_exempt
from django.http import HttpResponse

@csrf_exempt
def webhook(request):
    stripe.api_key = settings.STRIPE_SECRET_KEY
    sig_header = request.headers.get('stripe-signature')
    payload = request.body
    event = None
    try:
            event = stripe.Webhook.construct_event(
                payload, sig_header, settings.STRIPE_WEBHOOK_SECRET
            )
    except stripe.error.SignatureVerificationError:
        # Invalid signature
        return HttpResponse(status=400)

    # Handle the checkout.session.completed event
    if event.type == "checkout.session.completed":
        # TODO: create line orders
        return HttpResponse(status=200)
    return HttpResponse(status=400)

Let’s break this down:

• We try to construct a Stripe event from the payload, the signature header, and the webhook secret: the first is used to build the actual event, and the last two variables are relevant to validate the authenticity of the request.
• If the signature verification fails, we return a 400 HTTP response. Remember that Stripe is actually calling this endpoint, not our customer, so Stripe will know what to do in this scenario.
• We check if the event type is checkout.session.completed, i.e., if a customer successfully paid for our product. For now, we don’t do much else here, but we will process the order in the next step.

Note: A Stripe event can have multiple types but we will only handle completed sessions in this post. However, you can (and should) extend a webhook by following the docs.

You should also add this view to urlpatterns:

# ecommerce_site/urls.py

# ... same imports as before

urlpatterns = [
    # ... same urls as before
    path("webhook", views.webhook, name="webhook"),  # ⬅️ new
]

If everything works well, once you click “buy”, you should be redirected to a Stripe payment page. Since we are in test mode, we can fill in the payment details with dummy data, like a 4242 4242 4242 4242 card:

Once you press Pay, Stripe should call the webhook view and redirect you to the purchase_success view. Congratulations, you have successfully processed a payment with Stripe!

Create the Orders and Notify Users

Once a purchase is completed, we need to do a few things in the webhook view:

• Save the order information in our database.
• Notify staff users about the recent purchase.
• Send a confirmation email to the customer.

Let’s create a LineOrder database model in ecommerce/models.py to store some of the order information:

# ecommerce/models.py

from django.db import models

class LineOrder(models.Model):
    quantity = models.IntegerField()
    name = models.CharField(max_length=255, null=True, blank=True)
    email = models.EmailField(null=True, blank=True)
    shipping_details = models.TextField(null=True, blank=True)
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return f"Order {self.id} - {self.quantity} units"

Remember to create and run the migrations:

python manage.py makemigrations # ⬅️ creates the migration files
python manage.py migrate # ⬅️ applies the migrations in the database

We can now create a function to process the orders and call it from the webhook view:

# ecommerce/views.py

@csrf_exempt
def webhook(request):
    # ...same code as before
        if event.type == "checkout.session.completed":
            create_line_orders(event.data.object) # ⬅️ new
            return HttpResponse(status=200)
        return HttpResponse(status=400)

# new ⬇️
def create_line_orders(session: stripe.checkout.Session):
    line_items = stripe.checkout.Session.list_line_items(session.id)
    for line_item in line_items.data:
        LineOrder.objects.create(
            name=session.customer_details.name,
            email=session.customer_details.email,
            shipping_details=session.shipping_details,
            quantity=line_item.quantity,
        )
    mail.send_mail(
        "Your order has been placed",
        f"""
        Hi {session.customer_details.name},
        Your order has been placed. Thank you for shopping with us!
        You will receive an email with tracking information shortly.

        Best,
        The one product e-commerce Team
        """,
        "from@example.com",
        [session.customer_details.email],
    )

    staff_users = User.objects.filter(is_staff=True)
    mail.send_mail(
        "You have a new order!",
        """
            Hi team!
            You have a new order in your shop! go to the admin page to see it.

            Best,
            The one product e-commerce Team
            """,
        "from@example.com",
        [user.email for user in staff_users],
    )

Let’s break this down:

• We first create line order instances from the Stripe session and send a confirmation email to the customer about their purchase.
• We then send an email to all staff users telling them to check the admin panel.

You can now register the LineOrder model in the admin panel, so it’s accessible to staff users:

# ecommerce/admin.py
from django.contrib import admin
from ecommerce.models import LineOrder

# Register your models here.
admin.site.register(LineOrder)

When staff users log in to the admin page, they will now be able to check new orders and process them accordingly — in this case, pack and ship mugs to the customer!

Some Tips to Optimize Your Django Store

Here are some tips to further improve on the store you've built:

• Tulis ujian - anda boleh melihat beberapa contoh dalam repositori GitHub.
• Jika anda mempunyai lebih banyak produk untuk dijual, buat model pangkalan data untuk mereka dan sambungkan LineOrder melalui ForeignKey.
• Konfigurasikan tetapan e-mel mengikut dokumentasi e-mel Django. Anda juga boleh menggunakan perpustakaan seperti django-post-office untuk mengurus templat dan baris gilir e-mel anda.
• Setelah anda menggunakan tapak web anda, buat webhook sebenar (bukan pendengar tempatan).
• Lihat dokumen Stripe untuk mendapatkan alternatif kepada proses pembayaran yang telah kami gariskan, termasuk borang pembayaran terbenam.

Membungkus

Dalam siri dua bahagian ini, kami berjaya membina tapak e-dagang satu produk menggunakan Django, htmx dan Stripe. Panduan ini telah membimbing anda melalui penyediaan projek Django anda, menyepadukan htmx untuk interaksi pengguna yang lancar dan menggabungkan pembayaran selamat dengan Stripe.

Kami juga merangkumi cara mengendalikan pemprosesan pesanan, termasuk menyimpan maklumat pesanan ke pangkalan data anda, memberitahu pengguna kakitangan tentang pembelian baharu dan menghantar e-mel pengesahan kepada pelanggan anda. Dengan asas ini, anda boleh menyesuaikan dan mengembangkan lagi tapak e-dagang anda untuk memenuhi keperluan khusus anda.

Selamat pengekodan!

P.S. Jika anda ingin membaca siaran Python sebaik sahaja ia keluar dari akhbar, langgan surat berita Python Wizardry kami dan jangan sekali-kali terlepas satu pun siaran!

Atas ialah kandungan terperinci Mengintegrasikan Stripe Menjadi Kedai Django Python Satu Produk. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!