Annabell Nikolaus

Annabell Nikolaus

1660503240

Accepter Les Paiements Cryptographiques Avec Django Et Coinbase

Dans ce didacticiel, nous allons intégrer Django à Coinbase Commerce pour accepter différents paiements cryptographiques. Nous examinerons deux approches différentes : Coinbase Charges et Coinbase Checkout.

Qu'est-ce que Coinbase Commerce ?

Coinbase Commerce est un service de paiement numérique d'entreprise proposé par Coinbase, qui permet aux commerçants d'accepter les paiements cryptographiques dans différentes devises numériques. Au moment de la rédaction de cet article, ils prennent en charge Bitcoin, Bitcoin Cash, DAI, Ethereum, Litecoin, Dogecoin et USD Coin. Coinbase Commerce est facile à intégrer dans votre application Web et élimine les tracas liés aux paiements cryptographiques.

Coinbase et Coinbase Commerce ne sont pas la même chose. Coinbase est un échange crypto et un gestionnaire de portefeuille, tandis que Coinbase Commerce est un fournisseur de services de paiement numérique pour les commerçants.

L'API Coinbase Commerce propose deux manières différentes d'accepter les paiements cryptographiques : Coinbase Charges et Coinbase Checkout.

Avantages des frais Coinbase :

  • hautement personnalisable
  • possibilité de joindre par programme des métadonnées

Avantages de Coinbase Checkout :

  • fonctionne hors de la boîte
  • tableau de bord de gestion des produits
  • paiement intégré

Pour la plupart des applications, nous recommandons l'API Charges car elle peut être personnalisée. Cela l'emporte sur la simplicité offerte par l'API Checkout. Si vous vendez un produit fixe et que la personnalisation ne joue pas un grand rôle, n'hésitez pas à utiliser l'API Checkout.

Configuration du projet

Dans ce didacticiel, nous montrerons comment mettre en place les deux approches, Coinbase Charges et Coinbase Checkout. Nous allons commencer avec la même configuration de projet pour chacun. Une fois mis en place, n'hésitez pas à suivre une ou les deux approches.

Configuration du projet Django

Commencez par créer un nouveau répertoire et configurez un nouveau projet Django :

$ mkdir django-coinbase && cd django-coinbase
$ python3.9 -m venv env
$ source env/bin/activate

(env)$ pip install django==3.2.8
(env)$ django-admin startproject core .

Après cela, créez une nouvelle application appelée payments:

(env)$ python manage.py startapp payments

Enregistrez l'application dans core/settings.py sousINSTALLED_APPS :

# core/settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'payments.apps.PaymentsConfig', # new
]

Ajoutez une vue fonctionnelle simple appelée home_viewà payment/views.py :

# payments/views.py

from django.shortcuts import render

def home_view(request):
    return render(request, 'home.html', {})

Créez un fichier urls.pypayments dans l' application :

# payments/urls.py

from django.urls import path

from . import views

urlpatterns = [
    path('', views.home_view, name='payments-home'),
]

Mettez à jour le fichier d'URL au niveau du projet avec l' paymentsapplication :

# core/urls.py

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

urlpatterns = [
    path('', include('payments.urls')), # new
    path('admin/', admin.site.urls),
]

Créez un dossier "templates" dédié et un fichier pour la page d'accueil :

(env)$ mkdir templates
(env)$ touch templates/home.html

Ensuite, ajoutez le code HTML suivant à templates/home.html :

<!-- templates/home.html -->

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Django + Coinbase</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/css/bootstrap.min.css" crossorigin="anonymous">
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/js/bootstrap.min.js" crossorigin="anonymous"></script>
  </head>
  <body>
    <div class="container mt-5">
      <a class="btn btn-primary" href="#">Purchase</a>
    </div>
  </body>
</html>

Assurez-vous de mettre à jour le fichier settings.py afin que Django sache rechercher un dossier "templates":

# core/settings.py

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': ['templates'], # new
        ...

Enfin, exécutez migratepour synchroniser la base runserverde données et démarrer le serveur Web local de Django :

(env)$ python manage.py migrate
(env)$ python manage.py runserver

C'est ça! Ouvrez http://localhost:8000/ dans votre navigateur préféré. Vous devriez voir la page d'accueil :

Page d'accueil de Django + Coinbase

Ajouter Coinbase Commerce

Ensuite, installez coinbase-commerce:

(env)$ pip install coinbase-commerce==1.0.1

Pour travailler avec l' API Coinbase Commerce , vous devrez créer un compte (si vous ne l'avez pas déjà fait). Après avoir créé un compte, connectez-vous et accédez à vos paramètres. Faites défiler jusqu'à la section "Clés API", cliquez sur "Créer une clé API" puis sur "Révéler". Copiez la clé API dans votre presse-papiers.

Clés API Coinbase

Ajoutez ensuite la clé au fichier settings.py :

# core/settings.py

COINBASE_COMMERCE_API_KEY = '<your coinbase api key here>'

Avant de passer à l'étape suivante, testons si nous pouvons récupérer les données de l'API. Entrez dans le shell Python à l'aide de la commande suivante :

(env)$ python manage.py shell

Importez les éléments suivants :

>>> from core import settings
>>> from coinbase_commerce.client import Client

Initialisez un nouveau client et listez les frais :

>>> client = Client(api_key=settings.COINBASE_COMMERCE_API_KEY)
>>> for charge in client.charge.list_paging_iter():
...     print("{!r}".format(charge))

Si tout fonctionne, client.charge.list_paging_iter()devrait être une liste vide. Tant que vous ne voyez pas l'erreur suivante, vous pouvez supposer que tout va bien :

coinbase_commerce.error.AuthenticationError: Request id 10780b77-1021-4b09-b53b-a590ea044380: No such API key.

Pages utiles pour travailler avec l'API Coinbase :

Avec cela, décidez de l'approche que vous souhaitez adopter, Coinbase Charges ou Coinbase Checkout.

Frais Coinbase

Cette partie du didacticiel montre comment accepter les paiements à l'aide de l' API Coinbase Charges .

Coinbase Charges est l'approche la plus personnalisable pour collecter les paiements cryptographiques. Avec cette approche, vous avez un contrôle total sur les frais.

Flux de travail :

  1. Utiliser un client pour se connecter à l'API Coinbase Commerce
  2. Créer une charge (à partir de JSON)
  3. Récupérez la charge nouvellement créée et transmettez-la au modèle
  4. Rediriger l'utilisateur vers le site hébergé par Coinbase Commerce
  5. (Facultatif) Vérifiez les frais à l'aide de webhooks

Créer un frais

Pour demander un paiement en crypto-monnaie, vous créez un débit . Étant donné que les paiements en crypto-monnaie sont des paiements push , une charge expirera après une période d'attente si aucun paiement n'a été détecté. Les charges sont identifiées par un code unique à 8 caractères.

Mettre home_viewà jour pour créer une charge :

# payments/views.py

from coinbase_commerce.client import Client
from django.shortcuts import render

from core import settings


def home_view(request):
    client = Client(api_key=settings.COINBASE_COMMERCE_API_KEY)
    domain_url = 'http://localhost:8000/'
    product = {
        'name': 'Coffee',
        'description': 'A really good local coffee.',
        'local_price': {
            'amount': '5.00',
            'currency': 'USD'
        },
        'pricing_type': 'fixed_price',
        'redirect_url': domain_url + 'success/',
        'cancel_url': domain_url + 'cancel/',
    }
    charge = client.charge.create(**product)

    return render(request, 'home.html', {
        'charge': charge,
    })

Nous avons d'abord initialisé le client en lui passant COINBASE_COMMERCE_API_KEY. Ensuite, nous avons créé un objet JSON qui représente notre produit (nous avons fourni le nom, la description, etc.). Nous avons également adopté redirect_urlet cancel_urlà la charge, que nous mettrons en œuvre ici sous peu. Nous avons ensuite décompressé l'objet JSON et utilisé le client pour créer une charge. Enfin, nous l'avons transmis au modèle d'accueil en tant que contexte.

Nous pouvons désormais accéder aux informations de facturation dans templates/home.html . Mettez à jour le modèle comme suit :

<!-- templates/home.html -->

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Django + Coinbase Charge</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/css/bootstrap.min.css" crossorigin="anonymous">
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/js/bootstrap.min.js" crossorigin="anonymous"></script>
  </head>
  <body>
    <div class="container mt-5">
      <div class="card w-25">
        <div class="card-body">
          <h5 class="card-title">{{ charge.name }}</h5>
          <p class="card-text">
            <span>{{ charge.description }}</span>
            <br>
            <span>${{ charge.pricing.local.amount }} {{ charge.pricing.local.currency }}</span>
          </p>
          <div>
            <a class="btn btn-primary w-100" href="{{ charge.hosted_url }}">Purchase</a>
          </div>
        </div>
      </div>
    </div>
  </body>
</html>

Reportez-vous à la documentation de l' API Charge pour toutes les informations relatives aux frais que vous pouvez afficher sur le modèle.

Exécutez le serveur de développement :

(env)$ python manage.py runserver

http://localhost:8000/ devrait maintenant ressembler à ceci :

Page d'accueil de Django + Coinbase

Ne le testez pas encore. Nous le ferons sous peu.

Créer les vues de redirection

Mettons en œuvre les vues pour redirect_urlet cancel_urlque nous avons passées à la charge.

Créez deux nouvelles vues dans payment/views.py :

# payments/views.py

def success_view(request):
    return render(request, 'success.html', {})


def cancel_view(request):
    return render(request, 'cancel.html', {})

Enregistrez les nouvelles vues dans payment/urls.py :

# payments/urls.py

from django.urls import path

from . import views

urlpatterns = [
    path('', views.home_view, name='payments-home'),
    path('success/', views.success_view, name='payments-success'), # new
    path('cancel/', views.cancel_view, name='payments-cancel'), # new
]

Et templates/success.html :

<!-- templates/success.html -->

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Django + Coinbase Charge</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/css/bootstrap.min.css" crossorigin="anonymous">
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/js/bootstrap.min.js" crossorigin="anonymous"></script>
  </head>
  <body>
    <div class="container mt-5">
      <p>Your payment has been successful.</p>
    </div>
  </body>
</html>

Et templates/cancel.html :

<!-- templates/cancel.html -->

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Django + Coinbase Charge</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/css/bootstrap.min.css" crossorigin="anonymous">
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/js/bootstrap.min.js" crossorigin="anonymous"></script>
  </head>
  <body>
    <div class="container mt-5">
      <p>Your payment has been cancelled.</p>
    </div>
  </body>
</html>

Maintenant, une fois le paiement confirmé, l'utilisateur sera redirigé vers redirect_url. Dans le cas où ils annulent le paiement (ou si le débit expire), ils seront redirigés vers cancel_url.

Essai

Malheureusement, Coinbase Commerce ne prend pas en charge les comptes sandbox pour les tests, ce qui signifie que vous devrez utiliser un vrai crypto pour tester votre application.

Exécutez le serveur, accédez à http://localhost:8000/ et cliquez sur le bouton "Acheter". Vous serez redirigé vers le site hébergé par Coinbase Commerce :

Frais commerciaux Coinbase

Lorsque vous sélectionnez une crypto-monnaie avec laquelle vous souhaitez payer, une adresse de portefeuille (et un code QR) s'affichera :

Adresses de frais de commerce Coinbase

Vous disposez alors de 60 minutes pour transférer la crypto avant l'expiration de la charge.

Après avoir envoyé la crypto, il faudra quelques minutes (selon la crypto-monnaie que vous utilisez) aux mineurs pour confirmer votre transaction. Une fois que la transaction a reçu le nombre requis de confirmations (basé sur la crypto-monnaie), vous serez redirigé vers l'URL associée à redirect_url.

Les paiements apparaîtront dans le tableau de bord Commerce sous "Paiements":

Paiements commerciaux Coinbase

Passez à la section "Confirmer les paiements avec les webhooks" pour en savoir plus sur la confirmation de paiement.

Caisse Coinbase

Cette partie du didacticiel montre comment accepter les paiements à l'aide de l' API Coinbase Checkout . Si vous avez décidé d'opter pour Coinbase Charges, n'hésitez pas à ignorer cette section et à passer à la section "Confirmer les paiements avec les Webhooks".

Coinbase Checkout est le moyen le plus simple de collecter des paiements cryptographiques avec Coinbase Commerce. Avec cette approche, des frais seront automatiquement générés pour vous. Cette approche est appropriée lorsque vous travaillez avec des produits fixes.

Flux de travail :

  1. Utiliser un client pour se connecter à l'API Coinbase Commerce
  2. Récupérez un paiement à partir de l'API Coinbase Commerce et transmettez-le au modèle
  3. (Facultatif) Ajoutez le code HTML requis au modèle s'il s'agit de paiements intégrés
  4. Redirigez l'utilisateur vers le site hébergé par Coinbase Commerce OU utilisez un paiement intégré
  5. (Facultatif) Vérifiez les frais à l'aide de webhooks

Créer une caisse

Il existe deux manières de créer une caisse :

  1. Par programmation via la bibliothèque coinbase-commerce
  2. Manuellement dans le tableau de bord Coinbase Commerce

Pour plus de simplicité, nous utiliserons le Commerce Dashboard .

Accédez à "Commandes" et cliquez sur "Créer une caisse":

Paiement du commerce Coinbase

Cliquez sur "Vendre un produit". Saisissez le nom, la description et le prix du produit. Cliquez sur Suivant". Sous "Informations client", sélectionnez "Ne collectez aucune information". Ensuite, cliquez sur "Terminé.

Coinbase Commerce a généré tout le code HTML nécessaire que vous devez ajouter à votre modèle d'accueil. Vous pouvez le voir sous l'onglet "Intégrer". Pour rendre l'application Web plus modulaire et réutilisable, nous allons récupérer les informations de paiement dans le home_viewau lieu de les coder en dur dans le modèle. Pour ce faire, nous devons d'abord obtenir l'ID de paiement en copiant l'URL de la page hébergée :

Paiement du commerce Coinbase

Le lien permanent devrait ressembler à ceci :

https://commerce.coinbase.com/checkout/df2d7c68-145e-4537-86fa-1cac705eb748

Nous ne nous intéressons qu'au dernier segment de l'URL, qui représente l'ID de paiement :

df2d7c68-145e-4537-86fa-1cac705eb748

Enregistrez ceci dans le fichier core/settings.py comme suit :

# core/settings.py

COINBASE_CHECKOUT_ID = '<your checkout id>'

Mettre à jour les paiements/vues.py :

# payments/views.py

from coinbase_commerce.client import Client
from django.shortcuts import render

from core import settings


def home_view(request):
    client = Client(api_key=settings.COINBASE_COMMERCE_API_KEY)
    checkout = client.checkout.retrieve(settings.COINBASE_CHECKOUT_ID)
    checkout_link = f'https://commerce.coinbase.com/checkout/{checkout.id}'

    return render(request, 'home.html', {
        'checkout': checkout,
        'checkout_link': checkout_link,
    })

Ce code récupère le paiement et le transmet au modèle.

Enfin, nous devons modifier le modèle d'accueil pour utiliser la caisse. Vous pouvez soit utiliser un :

  1. Page hébergée - l'utilisateur est redirigé vers un site Web Coinbase Checkout
  2. Page intégrée - tout se passe sur votre site Web

À des fins éducatives, nous utiliserons les deux approches.

Mettre à jour templates/home.html :

<!-- templates/home.html -->

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Django + Coinbase Checkout</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/css/bootstrap.min.css" crossorigin="anonymous">
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/js/bootstrap.min.js" crossorigin="anonymous"></script>
  </head>
  <body>
    <div class="container mt-5">
      <div class="card w-25">
        <!-- Coinbase checkout details -->
        <div class="card-body">
          <h5 class="card-title">{{ checkout.name }}</h5>
          <p class="card-text">
            {{ checkout.description }}<br>
            {{ checkout.local_price.amount }} {{ checkout.local_price.currency }}
          </p>
          <div>
            <!-- Coinbase hosted approach (script not required) -->
            <a class="btn btn-primary w-100" href="{{ checkout_link }}">Purchase (hosted)</a>
            <!-- Coinbase embedded approach (script required) -->
            <div class="mt-2">
              <a class="btn btn-primary buy-with-crypto w-100" href="{{ checkout_link }}">Purchase (embedded)</a>
              <script src="https://commerce.coinbase.com/v1/checkout.js?version=201807"></script>
            </div>
          </div>
        </div>
      </div>
    </div>
  </body>
</html>

Exécutez le serveur et accédez à http://localhost:8000/ :

Exemple de paiement Coinbase Commerce

L'application est complètement fonctionnelle à ce stade. Ne testez rien pour l'instant cependant. Nous le ferons dans la section suivante.

Essai

Malheureusement, Coinbase Commerce ne prend pas en charge les comptes sandbox pour les tests, ce qui signifie que vous devrez utiliser un vrai crypto pour tester votre application.

Avec le serveur en cours d'exécution, accédez à http://localhost:8000/ . Vous pouvez tester en utilisant le site hébergé Coinbase ou le paiement intégré. Votre choix.

Lorsque vous sélectionnez une crypto-monnaie avec laquelle vous souhaitez payer, une adresse de portefeuille (et un code QR) s'affichera :

Adresses de frais de commerce Coinbase

Vous disposez alors de 60 minutes pour transférer la crypto avant l'expiration de la charge.

Après avoir envoyé la crypto, il faudra quelques minutes (selon la crypto-monnaie que vous utilisez) aux mineurs pour confirmer votre transaction. Une fois que la transaction a reçu le nombre requis de confirmations (basé sur la crypto-monnaie), un message "Paiement terminé" s'affiche.

Les paiements apparaîtront dans le tableau de bord Commerce sous "Paiements":

Paiements commerciaux Coinbase

Confirmer les paiements avec les Webhooks

Notre application fonctionne bien pour le moment, mais nous ne pouvons pas encore confirmer les paiements par programmation. Nous redirigeons simplement l'utilisateur vers la page de réussite après son paiement, mais nous ne pouvons pas compter uniquement sur cette page car la confirmation de paiement se produit de manière asynchrone.

Vous traitez souvent deux types d'événements différents lors de la programmation : les événements synchrones, qui ont un effet et des résultats immédiats (par exemple, la création d'une charge), et les événements asynchrones, qui n'ont pas de résultat immédiat (par exemple, la confirmation des paiements). Étant donné que la confirmation de paiement est effectuée de manière asynchrone, l'utilisateur peut être redirigé vers la page de réussite avant que son paiement ne soit confirmé et avant que nous recevions ses fonds.

Pour être averti lorsque le paiement est effectué, vous devez créer un webhook . Nous devrons créer un point de terminaison simple dans notre application, que Coinbase Commerce appellera chaque fois qu'un événement se produit (c'est-à-dire lorsqu'une charge est confirmée). En utilisant des webhooks, nous pouvons être sûrs que le paiement a bien été effectué.

Pour utiliser les webhooks, nous devons :

  1. Configurer le point de terminaison du webhook dans l'application
  2. Enregistrez le point de terminaison dans le tableau de bord Coinbase Commerce

Configurer le point de terminaison

Créez une coinbase_webhookvue dans payment/views.py :

# payments/views.py

@csrf_exempt
@require_http_methods(['POST'])
def coinbase_webhook(request):
    logger = logging.getLogger(__name__)

    request_data = request.body.decode('utf-8')
    request_sig = request.headers.get('X-CC-Webhook-Signature', None)
    webhook_secret = settings.COINBASE_COMMERCE_WEBHOOK_SHARED_SECRET

    try:
        event = Webhook.construct_event(request_data, request_sig, webhook_secret)

        # List of all Coinbase webhook events:
        # https://commerce.coinbase.com/docs/api/#webhooks

        if event['type'] == 'charge:confirmed':
            logger.info('Payment confirmed.')
            # TODO: run some custom code here

    except (SignatureVerificationError, WebhookInvalidPayload) as e:
        return HttpResponse(e, status=400)

    logger.info(f'Received event: id={event.id}, type={event.type}')
    return HttpResponse('ok', status=200)

Ce bloc de code valide la signature et la charge utile de la requête, puis génère un événement à partir de celle-ci. Vous pouvez maintenant vérifier le type d'événement et effectuer différentes actions en fonction du type.

Mettez à jour les importations :

import logging

from coinbase_commerce.client import Client
from coinbase_commerce.error import SignatureVerificationError, WebhookInvalidPayload
from coinbase_commerce.webhook import Webhook
from django.http import HttpResponse
from django.shortcuts import render
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_http_methods

from core import settings

Ignorez l'erreur qui COINBASE_COMMERCE_WEBHOOK_SHARED_SECRETn'existe pas encore. Nous l'ajouterons à l'étape suivante.

Enregistrez l'URL dans payment/urls.py :

# payments/urls.py

from django.urls import path

from . import views

urlpatterns = [
    path('', views.home_view, name='payments-home'),
    path('success/', views.success_view, name='payments-success'),   # only for the Coinbase charges approach
    path('cancel/', views.cancel_view, name='payments-cancel'),      # only for the Coinbase charges approach
    path('webhook/', views.coinbase_webhook),  # new
]

La coinbase_webhookvue sert maintenant de point de terminaison de webhook auquel Coinbase Commerce enverra les événements lorsqu'ils se produiront.

Si vous avez suivi l'approche Coinbase Checkout, n'incluez pas les URL success/ou .cancel/

Identifier l'utilisateur

Pour identifier l'utilisateur dans votre webhook, vous devez transmettre certaines métadonnées lors de la création de la charge ou lors du démarrage de la session de paiement. Vous pourrez ensuite récupérer ces métadonnées dans votre webhook.

La manière dont vous transmettez les métadonnées est différente selon l'approche que vous avez utilisée :

  1. API Charges - vous devrez joindre des métadonnées au produit
  2. API de paiement - vous devrez transmettre les métadonnées en tant qu'attribut HTML

Identifier l'utilisateur avec l'API Charges

Pour identifier l'utilisateur avec l'API Charges, commencez par ajouter ce qui suit au productdict à l'intérieurhome_view :

# payments/views.py

product = {
    ...
    'metadata': {
        'customer_id': request.user.id if request.user.is_authenticated else None,
        'customer_username': request.user.username if request.user.is_authenticated else None,
    },
    ...
}

Ce bloc de code associe l'ID utilisateur et le nom d'utilisateur de l'utilisateur authentifié.

Vous pouvez maintenant accéder aux métadonnées à l'intérieur de la coinbase_webhookvue comme suit :

# payments/views.py

@csrf_exempt
@require_http_methods(['POST'])
def coinbase_webhook(request):
    logger = logging.getLogger(__name__)

    request_data = request.body.decode('utf-8')
    request_sig = request.headers.get('X-CC-Webhook-Signature', None)
    webhook_secret = settings.COINBASE_COMMERCE_WEBHOOK_SHARED_SECRET

    try:
        event = Webhook.construct_event(request_data, request_sig, webhook_secret)

        # List of all Coinbase webhook events:
        # https://commerce.coinbase.com/docs/api/#webhooks

        if event['type'] == 'charge:confirmed':
            logger.info('Payment confirmed.')
            customer_id = event['data']['metadata']['customer_id'] # new
            customer_username = event['data']['metadata']['customer_username'] # new
            # TODO: run some custom code here
            # you can also use 'customer_id' or 'customer_username'
            # to fetch an actual Django user

    except (SignatureVerificationError, WebhookInvalidPayload) as e:
        return HttpResponse(e, status=400)

    logger.info(f'Received event: id={event.id}, type={event.type}')
    return HttpResponse('ok', status=200)

Identifier l'utilisateur avec l'API Checkout

Pour identifier l'utilisateur avec l'API Checkout, nous devons ajouter les métadonnées en tant data-customqu'attribut de données aux ancres dans templates/home.html :

Par exemple:

<div>
  <!-- Coinbase hosted approach (script not required) -->
  <a
    class="btn btn-primary w-100"
    {% if user.is_authenticated %}data-custom="{{ user.pk }}"{% endif %}
    href="{{ checkout_link }}"
  >Purchase (hosted)</a>
  <!-- Coinbase embedded approach (script required) -->
  <div class="mt-2">
    <a
      class="btn btn-primary buy-with-crypto w-100"
      {% if user.is_authenticated %}data-custom="{{ user.pk }}"{% endif %}
      href="{{ checkout_link }}"
    >Purchase (embedded)</a>
    <script src="https://commerce.coinbase.com/v1/checkout.js?version=201807"></script>
  </div>
</div>

Vous pouvez ensuite récupérer les métadonnées à l'intérieur de la coinbase_webhookvue comme suit :

# payments/views.py

@csrf_exempt
@require_http_methods(['POST'])
def coinbase_webhook(request):
    import logging

    request_data = request.body.decode('utf-8')
    request_sig = request.headers.get('X-CC-Webhook-Signature', None)
    webhook_secret = settings.COINBASE_COMMERCE_WEBHOOK_SHARED_SECRET

    try:
        event = Webhook.construct_event(request_data, request_sig, webhook_secret)

        # List of all Coinbase webhook events:
        # https://commerce.coinbase.com/docs/api/#webhooks

        if event['type'] == 'charge:confirmed':
            logger.info('Payment confirmed.')
            customer_id = event['data']['metadata']['custom'] # new
            # TODO: run some custom code here
            # you can also use 'customer_id'
            # to fetch an actual Django user

    except (SignatureVerificationError, WebhookInvalidPayload) as e:
        return HttpResponse(e, status=400)

    logger.info(f'Received event: id={event.id}, type={event.type}')
    return HttpResponse('ok', status=200)

Gardez à l'esprit que le webhook reçoit data-customdu texte brut. Assurez-vous de l'analyser en entier avant de l'utiliser pour extraire l'utilisateur de la base de données.

Enregistrer le point de terminaison

Accédez à https://commerce.coinbase.com/dashboard/settings , faites défiler jusqu'à "Abonnements Webhook" et cliquez sur "Ajouter un point de terminaison":

Coinbase Commerce Webhook

Entrez l'URL de votre point de terminaison et appuyez sur "Enregistrer".

L'URL doit commencer par HTTPS, ce qui signifie que vous devez déployer votre application avant de pouvoir la tester.

Ensuite, cliquez sur "Afficher le secret partagé" et copiez le secret :

Coinbase Commerce Webhook secret

Ajoutez le secret partagé au fichier settings.py comme suit :

# core/settings.py

COINBASE_COMMERCE_WEBHOOK_SHARED_SECRET = '<your coinbase webhook secret here>'

Tester le point de terminaison

Une fois votre application déployée, vous pouvez envoyer une demande de webhook de test à partir du tableau de bord Commerce . Accédez à "Abonnements Webhook" et cliquez sur "Détails" sous le point de terminaison du webhook :

Détails du webhook Coinbase Commerce

Cliquez ensuite sur "Envoyer le test":

Test des détails du webhook Coinbase Commerce

Enfin, sélectionnez "charge:confirmed" et cliquez à nouveau sur "Send Test". Vous devriez voir le message "Le paiement a été effectué avec succès". message de journalisation.

Conclusion

Dans ce didacticiel, vous avez appris à accepter les paiements cryptographiques avec Coinbase Commerce. Vous devriez maintenant pouvoir l'intégrer à Django et vérifier les paiements via un webhook.

Vous pouvez trouver le code dans les dépôts suivants sur GitHub :

  1. django-coinbase-frais
  2. django-coinbase-checkout

Source :  https://testdrive.io

#django #crypto #coinbase 

What is GEEK

Buddha Community

Accepter Les Paiements Cryptographiques Avec Django Et Coinbase
Ahebwe Oscar

Ahebwe Oscar

1620177818

Django admin full Customization step by step

Welcome to my blog , hey everyone in this article you learn how to customize the Django app and view in the article you will know how to register  and unregister  models from the admin view how to add filtering how to add a custom input field, and a button that triggers an action on all objects and even how to change the look of your app and page using the Django suit package let’s get started.

Database

Custom Titles of Django Admin

Exclude in Django Admin

Fields in Django Admin

#django #create super user django #customize django admin dashboard #django admin #django admin custom field display #django admin customization #django admin full customization #django admin interface #django admin register all models #django customization

Annabell Nikolaus

Annabell Nikolaus

1660503240

Accepter Les Paiements Cryptographiques Avec Django Et Coinbase

Dans ce didacticiel, nous allons intégrer Django à Coinbase Commerce pour accepter différents paiements cryptographiques. Nous examinerons deux approches différentes : Coinbase Charges et Coinbase Checkout.

Qu'est-ce que Coinbase Commerce ?

Coinbase Commerce est un service de paiement numérique d'entreprise proposé par Coinbase, qui permet aux commerçants d'accepter les paiements cryptographiques dans différentes devises numériques. Au moment de la rédaction de cet article, ils prennent en charge Bitcoin, Bitcoin Cash, DAI, Ethereum, Litecoin, Dogecoin et USD Coin. Coinbase Commerce est facile à intégrer dans votre application Web et élimine les tracas liés aux paiements cryptographiques.

Coinbase et Coinbase Commerce ne sont pas la même chose. Coinbase est un échange crypto et un gestionnaire de portefeuille, tandis que Coinbase Commerce est un fournisseur de services de paiement numérique pour les commerçants.

L'API Coinbase Commerce propose deux manières différentes d'accepter les paiements cryptographiques : Coinbase Charges et Coinbase Checkout.

Avantages des frais Coinbase :

  • hautement personnalisable
  • possibilité de joindre par programme des métadonnées

Avantages de Coinbase Checkout :

  • fonctionne hors de la boîte
  • tableau de bord de gestion des produits
  • paiement intégré

Pour la plupart des applications, nous recommandons l'API Charges car elle peut être personnalisée. Cela l'emporte sur la simplicité offerte par l'API Checkout. Si vous vendez un produit fixe et que la personnalisation ne joue pas un grand rôle, n'hésitez pas à utiliser l'API Checkout.

Configuration du projet

Dans ce didacticiel, nous montrerons comment mettre en place les deux approches, Coinbase Charges et Coinbase Checkout. Nous allons commencer avec la même configuration de projet pour chacun. Une fois mis en place, n'hésitez pas à suivre une ou les deux approches.

Configuration du projet Django

Commencez par créer un nouveau répertoire et configurez un nouveau projet Django :

$ mkdir django-coinbase && cd django-coinbase
$ python3.9 -m venv env
$ source env/bin/activate

(env)$ pip install django==3.2.8
(env)$ django-admin startproject core .

Après cela, créez une nouvelle application appelée payments:

(env)$ python manage.py startapp payments

Enregistrez l'application dans core/settings.py sousINSTALLED_APPS :

# core/settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'payments.apps.PaymentsConfig', # new
]

Ajoutez une vue fonctionnelle simple appelée home_viewà payment/views.py :

# payments/views.py

from django.shortcuts import render

def home_view(request):
    return render(request, 'home.html', {})

Créez un fichier urls.pypayments dans l' application :

# payments/urls.py

from django.urls import path

from . import views

urlpatterns = [
    path('', views.home_view, name='payments-home'),
]

Mettez à jour le fichier d'URL au niveau du projet avec l' paymentsapplication :

# core/urls.py

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

urlpatterns = [
    path('', include('payments.urls')), # new
    path('admin/', admin.site.urls),
]

Créez un dossier "templates" dédié et un fichier pour la page d'accueil :

(env)$ mkdir templates
(env)$ touch templates/home.html

Ensuite, ajoutez le code HTML suivant à templates/home.html :

<!-- templates/home.html -->

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Django + Coinbase</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/css/bootstrap.min.css" crossorigin="anonymous">
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/js/bootstrap.min.js" crossorigin="anonymous"></script>
  </head>
  <body>
    <div class="container mt-5">
      <a class="btn btn-primary" href="#">Purchase</a>
    </div>
  </body>
</html>

Assurez-vous de mettre à jour le fichier settings.py afin que Django sache rechercher un dossier "templates":

# core/settings.py

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': ['templates'], # new
        ...

Enfin, exécutez migratepour synchroniser la base runserverde données et démarrer le serveur Web local de Django :

(env)$ python manage.py migrate
(env)$ python manage.py runserver

C'est ça! Ouvrez http://localhost:8000/ dans votre navigateur préféré. Vous devriez voir la page d'accueil :

Page d'accueil de Django + Coinbase

Ajouter Coinbase Commerce

Ensuite, installez coinbase-commerce:

(env)$ pip install coinbase-commerce==1.0.1

Pour travailler avec l' API Coinbase Commerce , vous devrez créer un compte (si vous ne l'avez pas déjà fait). Après avoir créé un compte, connectez-vous et accédez à vos paramètres. Faites défiler jusqu'à la section "Clés API", cliquez sur "Créer une clé API" puis sur "Révéler". Copiez la clé API dans votre presse-papiers.

Clés API Coinbase

Ajoutez ensuite la clé au fichier settings.py :

# core/settings.py

COINBASE_COMMERCE_API_KEY = '<your coinbase api key here>'

Avant de passer à l'étape suivante, testons si nous pouvons récupérer les données de l'API. Entrez dans le shell Python à l'aide de la commande suivante :

(env)$ python manage.py shell

Importez les éléments suivants :

>>> from core import settings
>>> from coinbase_commerce.client import Client

Initialisez un nouveau client et listez les frais :

>>> client = Client(api_key=settings.COINBASE_COMMERCE_API_KEY)
>>> for charge in client.charge.list_paging_iter():
...     print("{!r}".format(charge))

Si tout fonctionne, client.charge.list_paging_iter()devrait être une liste vide. Tant que vous ne voyez pas l'erreur suivante, vous pouvez supposer que tout va bien :

coinbase_commerce.error.AuthenticationError: Request id 10780b77-1021-4b09-b53b-a590ea044380: No such API key.

Pages utiles pour travailler avec l'API Coinbase :

Avec cela, décidez de l'approche que vous souhaitez adopter, Coinbase Charges ou Coinbase Checkout.

Frais Coinbase

Cette partie du didacticiel montre comment accepter les paiements à l'aide de l' API Coinbase Charges .

Coinbase Charges est l'approche la plus personnalisable pour collecter les paiements cryptographiques. Avec cette approche, vous avez un contrôle total sur les frais.

Flux de travail :

  1. Utiliser un client pour se connecter à l'API Coinbase Commerce
  2. Créer une charge (à partir de JSON)
  3. Récupérez la charge nouvellement créée et transmettez-la au modèle
  4. Rediriger l'utilisateur vers le site hébergé par Coinbase Commerce
  5. (Facultatif) Vérifiez les frais à l'aide de webhooks

Créer un frais

Pour demander un paiement en crypto-monnaie, vous créez un débit . Étant donné que les paiements en crypto-monnaie sont des paiements push , une charge expirera après une période d'attente si aucun paiement n'a été détecté. Les charges sont identifiées par un code unique à 8 caractères.

Mettre home_viewà jour pour créer une charge :

# payments/views.py

from coinbase_commerce.client import Client
from django.shortcuts import render

from core import settings


def home_view(request):
    client = Client(api_key=settings.COINBASE_COMMERCE_API_KEY)
    domain_url = 'http://localhost:8000/'
    product = {
        'name': 'Coffee',
        'description': 'A really good local coffee.',
        'local_price': {
            'amount': '5.00',
            'currency': 'USD'
        },
        'pricing_type': 'fixed_price',
        'redirect_url': domain_url + 'success/',
        'cancel_url': domain_url + 'cancel/',
    }
    charge = client.charge.create(**product)

    return render(request, 'home.html', {
        'charge': charge,
    })

Nous avons d'abord initialisé le client en lui passant COINBASE_COMMERCE_API_KEY. Ensuite, nous avons créé un objet JSON qui représente notre produit (nous avons fourni le nom, la description, etc.). Nous avons également adopté redirect_urlet cancel_urlà la charge, que nous mettrons en œuvre ici sous peu. Nous avons ensuite décompressé l'objet JSON et utilisé le client pour créer une charge. Enfin, nous l'avons transmis au modèle d'accueil en tant que contexte.

Nous pouvons désormais accéder aux informations de facturation dans templates/home.html . Mettez à jour le modèle comme suit :

<!-- templates/home.html -->

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Django + Coinbase Charge</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/css/bootstrap.min.css" crossorigin="anonymous">
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/js/bootstrap.min.js" crossorigin="anonymous"></script>
  </head>
  <body>
    <div class="container mt-5">
      <div class="card w-25">
        <div class="card-body">
          <h5 class="card-title">{{ charge.name }}</h5>
          <p class="card-text">
            <span>{{ charge.description }}</span>
            <br>
            <span>${{ charge.pricing.local.amount }} {{ charge.pricing.local.currency }}</span>
          </p>
          <div>
            <a class="btn btn-primary w-100" href="{{ charge.hosted_url }}">Purchase</a>
          </div>
        </div>
      </div>
    </div>
  </body>
</html>

Reportez-vous à la documentation de l' API Charge pour toutes les informations relatives aux frais que vous pouvez afficher sur le modèle.

Exécutez le serveur de développement :

(env)$ python manage.py runserver

http://localhost:8000/ devrait maintenant ressembler à ceci :

Page d'accueil de Django + Coinbase

Ne le testez pas encore. Nous le ferons sous peu.

Créer les vues de redirection

Mettons en œuvre les vues pour redirect_urlet cancel_urlque nous avons passées à la charge.

Créez deux nouvelles vues dans payment/views.py :

# payments/views.py

def success_view(request):
    return render(request, 'success.html', {})


def cancel_view(request):
    return render(request, 'cancel.html', {})

Enregistrez les nouvelles vues dans payment/urls.py :

# payments/urls.py

from django.urls import path

from . import views

urlpatterns = [
    path('', views.home_view, name='payments-home'),
    path('success/', views.success_view, name='payments-success'), # new
    path('cancel/', views.cancel_view, name='payments-cancel'), # new
]

Et templates/success.html :

<!-- templates/success.html -->

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Django + Coinbase Charge</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/css/bootstrap.min.css" crossorigin="anonymous">
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/js/bootstrap.min.js" crossorigin="anonymous"></script>
  </head>
  <body>
    <div class="container mt-5">
      <p>Your payment has been successful.</p>
    </div>
  </body>
</html>

Et templates/cancel.html :

<!-- templates/cancel.html -->

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Django + Coinbase Charge</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/css/bootstrap.min.css" crossorigin="anonymous">
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/js/bootstrap.min.js" crossorigin="anonymous"></script>
  </head>
  <body>
    <div class="container mt-5">
      <p>Your payment has been cancelled.</p>
    </div>
  </body>
</html>

Maintenant, une fois le paiement confirmé, l'utilisateur sera redirigé vers redirect_url. Dans le cas où ils annulent le paiement (ou si le débit expire), ils seront redirigés vers cancel_url.

Essai

Malheureusement, Coinbase Commerce ne prend pas en charge les comptes sandbox pour les tests, ce qui signifie que vous devrez utiliser un vrai crypto pour tester votre application.

Exécutez le serveur, accédez à http://localhost:8000/ et cliquez sur le bouton "Acheter". Vous serez redirigé vers le site hébergé par Coinbase Commerce :

Frais commerciaux Coinbase

Lorsque vous sélectionnez une crypto-monnaie avec laquelle vous souhaitez payer, une adresse de portefeuille (et un code QR) s'affichera :

Adresses de frais de commerce Coinbase

Vous disposez alors de 60 minutes pour transférer la crypto avant l'expiration de la charge.

Après avoir envoyé la crypto, il faudra quelques minutes (selon la crypto-monnaie que vous utilisez) aux mineurs pour confirmer votre transaction. Une fois que la transaction a reçu le nombre requis de confirmations (basé sur la crypto-monnaie), vous serez redirigé vers l'URL associée à redirect_url.

Les paiements apparaîtront dans le tableau de bord Commerce sous "Paiements":

Paiements commerciaux Coinbase

Passez à la section "Confirmer les paiements avec les webhooks" pour en savoir plus sur la confirmation de paiement.

Caisse Coinbase

Cette partie du didacticiel montre comment accepter les paiements à l'aide de l' API Coinbase Checkout . Si vous avez décidé d'opter pour Coinbase Charges, n'hésitez pas à ignorer cette section et à passer à la section "Confirmer les paiements avec les Webhooks".

Coinbase Checkout est le moyen le plus simple de collecter des paiements cryptographiques avec Coinbase Commerce. Avec cette approche, des frais seront automatiquement générés pour vous. Cette approche est appropriée lorsque vous travaillez avec des produits fixes.

Flux de travail :

  1. Utiliser un client pour se connecter à l'API Coinbase Commerce
  2. Récupérez un paiement à partir de l'API Coinbase Commerce et transmettez-le au modèle
  3. (Facultatif) Ajoutez le code HTML requis au modèle s'il s'agit de paiements intégrés
  4. Redirigez l'utilisateur vers le site hébergé par Coinbase Commerce OU utilisez un paiement intégré
  5. (Facultatif) Vérifiez les frais à l'aide de webhooks

Créer une caisse

Il existe deux manières de créer une caisse :

  1. Par programmation via la bibliothèque coinbase-commerce
  2. Manuellement dans le tableau de bord Coinbase Commerce

Pour plus de simplicité, nous utiliserons le Commerce Dashboard .

Accédez à "Commandes" et cliquez sur "Créer une caisse":

Paiement du commerce Coinbase

Cliquez sur "Vendre un produit". Saisissez le nom, la description et le prix du produit. Cliquez sur Suivant". Sous "Informations client", sélectionnez "Ne collectez aucune information". Ensuite, cliquez sur "Terminé.

Coinbase Commerce a généré tout le code HTML nécessaire que vous devez ajouter à votre modèle d'accueil. Vous pouvez le voir sous l'onglet "Intégrer". Pour rendre l'application Web plus modulaire et réutilisable, nous allons récupérer les informations de paiement dans le home_viewau lieu de les coder en dur dans le modèle. Pour ce faire, nous devons d'abord obtenir l'ID de paiement en copiant l'URL de la page hébergée :

Paiement du commerce Coinbase

Le lien permanent devrait ressembler à ceci :

https://commerce.coinbase.com/checkout/df2d7c68-145e-4537-86fa-1cac705eb748

Nous ne nous intéressons qu'au dernier segment de l'URL, qui représente l'ID de paiement :

df2d7c68-145e-4537-86fa-1cac705eb748

Enregistrez ceci dans le fichier core/settings.py comme suit :

# core/settings.py

COINBASE_CHECKOUT_ID = '<your checkout id>'

Mettre à jour les paiements/vues.py :

# payments/views.py

from coinbase_commerce.client import Client
from django.shortcuts import render

from core import settings


def home_view(request):
    client = Client(api_key=settings.COINBASE_COMMERCE_API_KEY)
    checkout = client.checkout.retrieve(settings.COINBASE_CHECKOUT_ID)
    checkout_link = f'https://commerce.coinbase.com/checkout/{checkout.id}'

    return render(request, 'home.html', {
        'checkout': checkout,
        'checkout_link': checkout_link,
    })

Ce code récupère le paiement et le transmet au modèle.

Enfin, nous devons modifier le modèle d'accueil pour utiliser la caisse. Vous pouvez soit utiliser un :

  1. Page hébergée - l'utilisateur est redirigé vers un site Web Coinbase Checkout
  2. Page intégrée - tout se passe sur votre site Web

À des fins éducatives, nous utiliserons les deux approches.

Mettre à jour templates/home.html :

<!-- templates/home.html -->

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Django + Coinbase Checkout</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/css/bootstrap.min.css" crossorigin="anonymous">
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/js/bootstrap.min.js" crossorigin="anonymous"></script>
  </head>
  <body>
    <div class="container mt-5">
      <div class="card w-25">
        <!-- Coinbase checkout details -->
        <div class="card-body">
          <h5 class="card-title">{{ checkout.name }}</h5>
          <p class="card-text">
            {{ checkout.description }}<br>
            {{ checkout.local_price.amount }} {{ checkout.local_price.currency }}
          </p>
          <div>
            <!-- Coinbase hosted approach (script not required) -->
            <a class="btn btn-primary w-100" href="{{ checkout_link }}">Purchase (hosted)</a>
            <!-- Coinbase embedded approach (script required) -->
            <div class="mt-2">
              <a class="btn btn-primary buy-with-crypto w-100" href="{{ checkout_link }}">Purchase (embedded)</a>
              <script src="https://commerce.coinbase.com/v1/checkout.js?version=201807"></script>
            </div>
          </div>
        </div>
      </div>
    </div>
  </body>
</html>

Exécutez le serveur et accédez à http://localhost:8000/ :

Exemple de paiement Coinbase Commerce

L'application est complètement fonctionnelle à ce stade. Ne testez rien pour l'instant cependant. Nous le ferons dans la section suivante.

Essai

Malheureusement, Coinbase Commerce ne prend pas en charge les comptes sandbox pour les tests, ce qui signifie que vous devrez utiliser un vrai crypto pour tester votre application.

Avec le serveur en cours d'exécution, accédez à http://localhost:8000/ . Vous pouvez tester en utilisant le site hébergé Coinbase ou le paiement intégré. Votre choix.

Lorsque vous sélectionnez une crypto-monnaie avec laquelle vous souhaitez payer, une adresse de portefeuille (et un code QR) s'affichera :

Adresses de frais de commerce Coinbase

Vous disposez alors de 60 minutes pour transférer la crypto avant l'expiration de la charge.

Après avoir envoyé la crypto, il faudra quelques minutes (selon la crypto-monnaie que vous utilisez) aux mineurs pour confirmer votre transaction. Une fois que la transaction a reçu le nombre requis de confirmations (basé sur la crypto-monnaie), un message "Paiement terminé" s'affiche.

Les paiements apparaîtront dans le tableau de bord Commerce sous "Paiements":

Paiements commerciaux Coinbase

Confirmer les paiements avec les Webhooks

Notre application fonctionne bien pour le moment, mais nous ne pouvons pas encore confirmer les paiements par programmation. Nous redirigeons simplement l'utilisateur vers la page de réussite après son paiement, mais nous ne pouvons pas compter uniquement sur cette page car la confirmation de paiement se produit de manière asynchrone.

Vous traitez souvent deux types d'événements différents lors de la programmation : les événements synchrones, qui ont un effet et des résultats immédiats (par exemple, la création d'une charge), et les événements asynchrones, qui n'ont pas de résultat immédiat (par exemple, la confirmation des paiements). Étant donné que la confirmation de paiement est effectuée de manière asynchrone, l'utilisateur peut être redirigé vers la page de réussite avant que son paiement ne soit confirmé et avant que nous recevions ses fonds.

Pour être averti lorsque le paiement est effectué, vous devez créer un webhook . Nous devrons créer un point de terminaison simple dans notre application, que Coinbase Commerce appellera chaque fois qu'un événement se produit (c'est-à-dire lorsqu'une charge est confirmée). En utilisant des webhooks, nous pouvons être sûrs que le paiement a bien été effectué.

Pour utiliser les webhooks, nous devons :

  1. Configurer le point de terminaison du webhook dans l'application
  2. Enregistrez le point de terminaison dans le tableau de bord Coinbase Commerce

Configurer le point de terminaison

Créez une coinbase_webhookvue dans payment/views.py :

# payments/views.py

@csrf_exempt
@require_http_methods(['POST'])
def coinbase_webhook(request):
    logger = logging.getLogger(__name__)

    request_data = request.body.decode('utf-8')
    request_sig = request.headers.get('X-CC-Webhook-Signature', None)
    webhook_secret = settings.COINBASE_COMMERCE_WEBHOOK_SHARED_SECRET

    try:
        event = Webhook.construct_event(request_data, request_sig, webhook_secret)

        # List of all Coinbase webhook events:
        # https://commerce.coinbase.com/docs/api/#webhooks

        if event['type'] == 'charge:confirmed':
            logger.info('Payment confirmed.')
            # TODO: run some custom code here

    except (SignatureVerificationError, WebhookInvalidPayload) as e:
        return HttpResponse(e, status=400)

    logger.info(f'Received event: id={event.id}, type={event.type}')
    return HttpResponse('ok', status=200)

Ce bloc de code valide la signature et la charge utile de la requête, puis génère un événement à partir de celle-ci. Vous pouvez maintenant vérifier le type d'événement et effectuer différentes actions en fonction du type.

Mettez à jour les importations :

import logging

from coinbase_commerce.client import Client
from coinbase_commerce.error import SignatureVerificationError, WebhookInvalidPayload
from coinbase_commerce.webhook import Webhook
from django.http import HttpResponse
from django.shortcuts import render
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_http_methods

from core import settings

Ignorez l'erreur qui COINBASE_COMMERCE_WEBHOOK_SHARED_SECRETn'existe pas encore. Nous l'ajouterons à l'étape suivante.

Enregistrez l'URL dans payment/urls.py :

# payments/urls.py

from django.urls import path

from . import views

urlpatterns = [
    path('', views.home_view, name='payments-home'),
    path('success/', views.success_view, name='payments-success'),   # only for the Coinbase charges approach
    path('cancel/', views.cancel_view, name='payments-cancel'),      # only for the Coinbase charges approach
    path('webhook/', views.coinbase_webhook),  # new
]

La coinbase_webhookvue sert maintenant de point de terminaison de webhook auquel Coinbase Commerce enverra les événements lorsqu'ils se produiront.

Si vous avez suivi l'approche Coinbase Checkout, n'incluez pas les URL success/ou .cancel/

Identifier l'utilisateur

Pour identifier l'utilisateur dans votre webhook, vous devez transmettre certaines métadonnées lors de la création de la charge ou lors du démarrage de la session de paiement. Vous pourrez ensuite récupérer ces métadonnées dans votre webhook.

La manière dont vous transmettez les métadonnées est différente selon l'approche que vous avez utilisée :

  1. API Charges - vous devrez joindre des métadonnées au produit
  2. API de paiement - vous devrez transmettre les métadonnées en tant qu'attribut HTML

Identifier l'utilisateur avec l'API Charges

Pour identifier l'utilisateur avec l'API Charges, commencez par ajouter ce qui suit au productdict à l'intérieurhome_view :

# payments/views.py

product = {
    ...
    'metadata': {
        'customer_id': request.user.id if request.user.is_authenticated else None,
        'customer_username': request.user.username if request.user.is_authenticated else None,
    },
    ...
}

Ce bloc de code associe l'ID utilisateur et le nom d'utilisateur de l'utilisateur authentifié.

Vous pouvez maintenant accéder aux métadonnées à l'intérieur de la coinbase_webhookvue comme suit :

# payments/views.py

@csrf_exempt
@require_http_methods(['POST'])
def coinbase_webhook(request):
    logger = logging.getLogger(__name__)

    request_data = request.body.decode('utf-8')
    request_sig = request.headers.get('X-CC-Webhook-Signature', None)
    webhook_secret = settings.COINBASE_COMMERCE_WEBHOOK_SHARED_SECRET

    try:
        event = Webhook.construct_event(request_data, request_sig, webhook_secret)

        # List of all Coinbase webhook events:
        # https://commerce.coinbase.com/docs/api/#webhooks

        if event['type'] == 'charge:confirmed':
            logger.info('Payment confirmed.')
            customer_id = event['data']['metadata']['customer_id'] # new
            customer_username = event['data']['metadata']['customer_username'] # new
            # TODO: run some custom code here
            # you can also use 'customer_id' or 'customer_username'
            # to fetch an actual Django user

    except (SignatureVerificationError, WebhookInvalidPayload) as e:
        return HttpResponse(e, status=400)

    logger.info(f'Received event: id={event.id}, type={event.type}')
    return HttpResponse('ok', status=200)

Identifier l'utilisateur avec l'API Checkout

Pour identifier l'utilisateur avec l'API Checkout, nous devons ajouter les métadonnées en tant data-customqu'attribut de données aux ancres dans templates/home.html :

Par exemple:

<div>
  <!-- Coinbase hosted approach (script not required) -->
  <a
    class="btn btn-primary w-100"
    {% if user.is_authenticated %}data-custom="{{ user.pk }}"{% endif %}
    href="{{ checkout_link }}"
  >Purchase (hosted)</a>
  <!-- Coinbase embedded approach (script required) -->
  <div class="mt-2">
    <a
      class="btn btn-primary buy-with-crypto w-100"
      {% if user.is_authenticated %}data-custom="{{ user.pk }}"{% endif %}
      href="{{ checkout_link }}"
    >Purchase (embedded)</a>
    <script src="https://commerce.coinbase.com/v1/checkout.js?version=201807"></script>
  </div>
</div>

Vous pouvez ensuite récupérer les métadonnées à l'intérieur de la coinbase_webhookvue comme suit :

# payments/views.py

@csrf_exempt
@require_http_methods(['POST'])
def coinbase_webhook(request):
    import logging

    request_data = request.body.decode('utf-8')
    request_sig = request.headers.get('X-CC-Webhook-Signature', None)
    webhook_secret = settings.COINBASE_COMMERCE_WEBHOOK_SHARED_SECRET

    try:
        event = Webhook.construct_event(request_data, request_sig, webhook_secret)

        # List of all Coinbase webhook events:
        # https://commerce.coinbase.com/docs/api/#webhooks

        if event['type'] == 'charge:confirmed':
            logger.info('Payment confirmed.')
            customer_id = event['data']['metadata']['custom'] # new
            # TODO: run some custom code here
            # you can also use 'customer_id'
            # to fetch an actual Django user

    except (SignatureVerificationError, WebhookInvalidPayload) as e:
        return HttpResponse(e, status=400)

    logger.info(f'Received event: id={event.id}, type={event.type}')
    return HttpResponse('ok', status=200)

Gardez à l'esprit que le webhook reçoit data-customdu texte brut. Assurez-vous de l'analyser en entier avant de l'utiliser pour extraire l'utilisateur de la base de données.

Enregistrer le point de terminaison

Accédez à https://commerce.coinbase.com/dashboard/settings , faites défiler jusqu'à "Abonnements Webhook" et cliquez sur "Ajouter un point de terminaison":

Coinbase Commerce Webhook

Entrez l'URL de votre point de terminaison et appuyez sur "Enregistrer".

L'URL doit commencer par HTTPS, ce qui signifie que vous devez déployer votre application avant de pouvoir la tester.

Ensuite, cliquez sur "Afficher le secret partagé" et copiez le secret :

Coinbase Commerce Webhook secret

Ajoutez le secret partagé au fichier settings.py comme suit :

# core/settings.py

COINBASE_COMMERCE_WEBHOOK_SHARED_SECRET = '<your coinbase webhook secret here>'

Tester le point de terminaison

Une fois votre application déployée, vous pouvez envoyer une demande de webhook de test à partir du tableau de bord Commerce . Accédez à "Abonnements Webhook" et cliquez sur "Détails" sous le point de terminaison du webhook :

Détails du webhook Coinbase Commerce

Cliquez ensuite sur "Envoyer le test":

Test des détails du webhook Coinbase Commerce

Enfin, sélectionnez "charge:confirmed" et cliquez à nouveau sur "Send Test". Vous devriez voir le message "Le paiement a été effectué avec succès". message de journalisation.

Conclusion

Dans ce didacticiel, vous avez appris à accepter les paiements cryptographiques avec Coinbase Commerce. Vous devriez maintenant pouvoir l'intégrer à Django et vérifier les paiements via un webhook.

Vous pouvez trouver le code dans les dépôts suivants sur GitHub :

  1. django-coinbase-frais
  2. django-coinbase-checkout

Source :  https://testdrive.io

#django #crypto #coinbase 

Ahebwe Oscar

Ahebwe Oscar

1620185280

How model queries work in Django

How model queries work in Django

Welcome to my blog, hey everyone in this article we are going to be working with queries in Django so for any web app that you build your going to want to write a query so you can retrieve information from your database so in this article I’ll be showing you all the different ways that you can write queries and it should cover about 90% of the cases that you’ll have when you’re writing your code the other 10% depend on your specific use case you may have to get more complicated but for the most part what I cover in this article should be able to help you so let’s start with the model that I have I’ve already created it.

**Read More : **How to make Chatbot in Python.

Read More : Django Admin Full Customization step by step

let’s just get into this diagram that I made so in here:

django queries aboutDescribe each parameter in Django querset

we’re making a simple query for the myModel table so we want to pull out all the information in the database so we have this variable which is gonna hold a return value and we have our myModel models so this is simply the myModel model name so whatever you named your model just make sure you specify that and we’re gonna access the objects attribute once we get that object’s attribute we can simply use the all method and this will return all the information in the database so we’re gonna start with all and then we will go into getting single items filtering that data and go to our command prompt.

Here and we’ll actually start making our queries from here to do this let’s just go ahead and run** Python manage.py shell** and I am in my project file so make sure you’re in there when you start and what this does is it gives us an interactive shell to actually start working with our data so this is a lot like the Python shell but because we did manage.py it allows us to do things a Django way and actually query our database now open up the command prompt and let’s go ahead and start making our first queries.

#django #django model queries #django orm #django queries #django query #model django query #model query #query with django

Ananya Gupta

Ananya Gupta

1597123834

Main Pros and Cons of Django As A Web Framework for Python Developers

Django depicts itself as “the web system for fussbudgets with cutoff times”. It was intended to help Python engineers take applications from idea to consummation as fast as could be expected under the circumstances.

It permits fast turn of events on the off chance that you need to make a CRUD application with batteries included. With Django, you won’t need to rehash an already solved problem. It just works and lets you center around your business rationale and making something clients can utilize.

Pros of Django

“Batteries included” theory

The standard behind batteries-included methods normal usefulness for building web applications accompanies the system, not as isolated libraries.

Django incorporates much usefulness you can use to deal with normal web advancement undertakings. Here are some significant level functionalities that Django gives you, which else you need to stay together if you somehow happened to utilize a small scale structure:

ORM

Database relocations

Client validation

Administrator board

Structures

Normalized structure

Django as a system proposes the right structure of an undertaking. That structure helps designers in making sense of how and where to execute any new component.

With a generally acknowledged venture structure that is like numerous tasks, it is a lot simpler to discover online good arrangements or approach the network for help. There are numerous energetic Python designers who will assist you with comprehending any issue you may experience.

Django applications

Django applications (or applications for short) permit designers to separate a task into numerous applications. An application is whatever is introduced by putting in settings.INSTALLED_APPS. This makes it simpler for engineers to add usefulness to the web application by coordinating outer Django applications into the venture.

There are many reusable modules and applications to accelerate your turn of events learn through Online Django Class and Check the Django website.

Secure of course

Django gives great security assurance out of the crate and incorporates avoidance components for basic assaults like SQL Injection (XSS) and Cross-site Request Forgery (CSRF). You can discover more subtleties in the official security diagram control.

REST structure for building APIs

Django REST Framework, commonly condensed “DRF”, is a Python library for building APIs. It has secluded and adaptable engineering that functions admirably for both straightforward and complex web APIs.

DRF gives a lot of verification and authorization strategies out of the case. It is an adaptable, full-included library with measured and adjustable engineering. It accompanies nonexclusive classes for CRUD tasks and an implicit API program for testing API endpoints.

GraphQL structure for building APIs

Huge REST APIs regularly require a lot of solicitations to various endpoints to recover every single required datum. GraphQL it’s a question language that permits us to share related information in a lot simpler design. For a prologue to GraphQL and an outline of its ideas, if it’s not too much trouble allude to the authority GraphQL documentation.

Graphene-Django gives reflections that make it simple to add GraphQL usefulness to your Django venture. Ordinary Django models, structures, validation, consent arrangements, and different functionalities can be reused to manufacture GraphQL blueprint. It additionally gives an implicit API program for testing API endpoints.

Cons of Django

Django ORM

Django ORM, made before SQLAlchemy existed, is currently much sub-par compared to SQLAlchemy. It depends on the Active Record design which is more regrettable than the Unit of Work design embraced by SQLAlchemy. This implies, in Django, models can “spare” themselves and exchanges are off as a matter of course, they are a bit of hindsight. Peruse more in Why I kind of aversion Django.

Django advances course popularity increses day by day:

Django is huge and is viewed as strong bit of programming. This permits the network to create several reusable modules and applications yet has additionally restricted the speed of advancement of the Django. On head of that Django needs to keep up in reverse similarity, so it advances gradually.

Rundown - Should I use Django as a Python designer?

While Django ORM isn’t as adaptable as SQLAlchemy and the enormous environment of reusable modules and applications hinders structure advancement - plainly Django ought to be the best option web system for Python engineers.

Elective, light systems, similar to Flask, while offering a retreat from Django huge biological system and designs, in the long haul can require substantially more additional libraries and usefulness, in the end making many experienced Python engineers winding up wishing they’d began with Django.

Django undertaking’s security and network have become enormously over the previous decade since the system’s creation. Official documentation and instructional exercises are probably the best anyplace in programming advancement. With each delivery, Django keeps on including huge new usefulness.

#django online training #django online course #online django course #django course #django training #django certification course

Marget D

Marget D

1626077187

4 key Features of Django Framework that Make it the Best Amongst all!

Django is one of the popular python based open-source web frameworks mainly used by the developers who like to have rapid development along with the clean pragmatic design.

Read this blog to know the various Django Features with details.

#django framework #django web development #django development company #django development services #python django development company #python django development