[PYTHON] Einfache Implementierung der Kreditkartenzahlungsfunktion mit PAY.JP [Django]

Was ist PAY.JP?

Offiziell: https://pay.jp/

Ein Service, der die Einführung von Kreditkartenzahlungen vereinfacht. Implementieren Sie mit den bereitgestellten APIs und SDKs.

Das von PAY.JP bereitgestellte Formular zur Eingabe von Karteninformationen lautet iframe

• Ich habe Angst, weil ich den Zahlungsmechanismus nicht verstehe
• Ich möchte eine Zahlungsfunktion für das Produkt einführen, aber es scheint schwierig zu sein, persönliche Informationen zu verwalten

PAYJP schützt den hohen Schwellenwert für die Zahlung vollständig vor dem Eingabeteil des Kunden. Daher ist es für sie nicht erforderlich, persönliche Informationen wie die vom Benutzer eingegebene Kartennummer zu verwalten, und es scheint, dass sie durch Einfügen mindestens einer Zeile JavaScript implementiert werden können. Es ist wunderbar.

Es scheint, dass Daten zu Zahlungen und Karteninformationen von REST-basierten APIs abgerufen werden können. Ich denke, die Dokumentation ist auch für Ingenieure leicht zu verstehen, daher denke ich, dass sie leicht zu implementieren ist. PAY.JP API-Referenz

Was zu implementieren

Zum Zeitpunkt des Schreibens sind die einzigen offiziellen Tutorials Flask und Sinatra. Die meisten anderen Qiita-Artikel wurden in Rails implementiert, daher werde ich sie in Django implementieren.

Führen Sie PAY.JP ein und implementieren Sie die Zahlungsfunktion.

• PAY.JP hat das Konzept von Produktion und Test. Da für die Produktion eine Anwendung erforderlich ist, um tatsächlich Geld auszutauschen, werden wir sie diesmal nicht verwenden. Wenn sie zum Testen verwendet wird, können Sie sie in Ihrer Umgebung ausprobieren.

Ausführungsumgebung

MacOS Catalina version: 10.15.5
Python 3.8.3
Django 3.0.8
payjp  0.0.5

Führen Sie zuerst Django aus

Erstellen Sie einen Ordner für das Beispielprojekt und verschieben Sie ihn in den Ordner.

$ mkdir my-project; cd my-project

Installieren Sie die erforderlichen Bibliotheken (django, payjp).

$ pip install django payjp

Generieren Sie ein Django-Projekt

$ django-admin startproject project .

Stellen Sie sicher, dass der Entwicklungsserver mit dem folgenden Code in dem Verzeichnis gestartet wird, in dem manage.py generiert wird.

$ python manage.py runserver

Überprüfen Sie den API-Schlüssel für die Verwendung von PAYJP

Sie können den API-Schlüssel über "API" in der linken Seitenleiste überprüfen, indem Sie auf PAYJP-Einstellungsbildschirm zugreifen. Dieses Mal möchte ich es nur in meiner Umgebung ausführen, daher verwende ich den privaten Testschlüssel und den öffentlichen Testschlüssel.

Jetzt, da Sie bereit sind zu arbeiten, erstellen wir eine Anwendung und arbeiten mit PAYJP.

Generieren Sie eine Django-Anwendung, die mit PAY.JP funktioniert.

$ python manage.py startapp app

Bearbeiten Sie die Django-Konfigurationsdatei

in settings.py Registrieren Sie die zuvor erstellte Anwendung und legen Sie den privaten Schlüssel von PAY.JP fest.

project/settings.py

...

import payjp

...

...

...

INSTALLED_APPS = [
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
    #hinzufügen
    "app", 
]

...

...

...

# PAY.JP-Einstellungen
payjp.api_key = "sk_test_xxxxxxxxxxxxxxxxxxxxx" #Testen Sie den privaten Schlüssel

Implementieren Sie View

app/views.py

from django.shortcuts import render
from django.views.generic import View

import payjp


# Create your views here.
class PayView(View):
    """
    use PAY.JP API
    """

    def get(self, request):
        #Übergeben Sie den öffentlichen Schlüssel
        return render(
            request, "index.html", {"public_key": "pk_test_xxxxxxxxxxxxxxxxxxxxxxxx"}
        )

    def post(self, request):
        amount = request.POST.get("amount")
        payjp_token = request.POST.get("payjp-token")

        #Generieren Sie Kundeninformationen aus Token
        customer = payjp.Customer.create(email="[email protected]", card=payjp_token)
        #Eine Zahlung tätigen
        charge = payjp.Charge.create(
            amount=amount,
            currency="jpy",
            customer=customer.id,
            description="Django example charge",
        )

        context = {"amount": amount, "customer": customer, "charge": charge}
        return render(request, "index.html", context)

Vorlage erstellen

app

$ mkdir templates; cd templates
$ touch index.html

app/templates/index.html

<!DOCTYPE html>
<html lang="ja">
<head>
  <meta charset="UTF-8" />
  <meta http-equiv="x-ua-compatible" content="IE=edge" />
  <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no" />
  <title>Beispielanwendung</title>
</head>

<body>
  <h1>Zahlung</h1>

  {% if charge %}
    <p>{{ amount }}Die Yen-Zahlung ist abgeschlossen.</p>
    <br>
    <p>customer: {{ customer }}</p>
    <br>
    <p>Charge: {{ charge }}</p>
  {% else %}
    <form action="{% url 'app' %}" method="post">
      {% csrf_token %}
      <div>
        <label for="amount">Zahlung</label>
        <input type="number" name="amount" id="amount" required>
      </div>

      <script type="text/javascript" src="https://checkout.pay.jp" class="payjp-button" data-key="{{ public_key }}">
      </script>
    </form>
  {% endif %}
</body>
</html>

Routing-Einstellungen

project/urls.py

from django.contrib import admin
from django.urls import path

from app import views

urlpatterns = [
    path("admin/", admin.site.urls),
    path("", views.PayView.as_view(), name="app")
]

Ich denke du hast es umgesetzt!

Endgültige Verzeichnisstruktur

my-project
├── app
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── migrations
│   ├── models.py
│   ├── payjp.py
│   ├── templates
│   │   └── index.html
│   ├── tests.py
│   └── views.py
├── manage.py
└── project
    ├── __init__.py
    ├── asgi.py
    ├── settings.py
    ├── urls.py
    └── wsgi.py

Funktionsprüfung

Führen Sie die Anwendung aus

$ python manage.py runserver

http://127.0.0.1:8000/ Wenn Sie zugreifen

Wird angezeigt, geben Sie den Zahlungsbetrag und die Karteninformationen ein.

Drücken Sie Pay with Card

Sie können auch die Zahlungsdetails auf PAY.JP überprüfen. Stellen Sie daher sicher, dass Sie über die zuvor eingegebenen Informationen verfügen. "Sales" -Element in der Seitenleiste

Schließlich

Django konnte die Zahlungsabwicklung problemlos implementieren! Diesmal habe ich das Standardformulardesign verwendet, aber es scheint, dass ich es anpassen kann, indem ich CSS selbst einstelle. Obwohl die Modellverarbeitung dieses Mal weggelassen wurde, ist es auch möglich, eine praktische Anwendung zu erstellen, indem die von der PAYJP-API zurückgegebene Antwort (Zahlungsinformationen usw.) zusammen mit den Benutzerinformationen in der Datenbank gespeichert wird. Korrekt.

Referenzlink:

PAY.JP API-Benutzerhandbuch PAY.JP API-Referenz