Marketplace avec Django

WAJUB_API_KEY = os.environ["WAJUB_API_KEY"]
WAJUB_WEBHOOK_SECRET = os.environ["WAJUB_WEBHOOK_SECRET"]
PLATFORM_COMMISSION_PERCENT = 10.0

from django.conf import settings
from wajub import Wajub

client = Wajub(
    api_key=settings.WAJUB_API_KEY,
    webhook_secret=settings.WAJUB_WEBHOOK_SECRET,
)

from django.conf import settings
from django.db import models


class Vendor(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    business_name = models.CharField(max_length=200)
    payout_phone = models.CharField(max_length=20, blank=True)

    sync_account_id = models.CharField(max_length=64, unique=True, null=True, blank=True)
    status = models.CharField(max_length=16, default="pending")
    payment_status = models.CharField(max_length=16, default="inactive")

    created_at = models.DateTimeField(auto_now_add=True)

    @property
    def can_sell(self) -> bool:
        return self.status == "active" and self.payment_status == "active"


class SyncDelivery(models.Model):
    key = models.CharField(max_length=128, unique=True)
    received_at = models.DateTimeField(auto_now_add=True)

from django.conf import settings
from rest_framework import status as http
from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from wajub import WajubError

from .models import Vendor
from .wajub import client


@api_view(["POST"])
@permission_classes([IsAuthenticated])
def onboard_vendor(request):
    vendor, _ = Vendor.objects.get_or_create(
        user=request.user,
        defaults={
            "business_name": request.data["business_name"],
            "payout_phone": request.data.get("payout_phone", ""),
        },
    )

    if vendor.sync_account_id:
        return Response({"error": "Already connected."}, status=http.HTTP_400_BAD_REQUEST)

    try:
        account = client.accounts.create({
            "reference": f"vendor-{vendor.id}",
            "capabilities": ["read", "payments", "refunds", "customers", "withdrawals"],
            "pricing": {
                "percentage_fee": settings.PLATFORM_COMMISSION_PERCENT,
                "currency": "XAF",
            },
            "callback": "https://marketplace.example.com/vendors/connected",
        })
    except WajubError as exc:
        return Response({"error": str(exc)}, status=http.HTTP_400_BAD_REQUEST)

    vendor.sync_account_id = account["id"]
    vendor.status = account["status"]
    vendor.save(update_fields=["sync_account_id", "status"])

    return Response(
        {"authorization_url": account["authorization_url"]},
        status=http.HTTP_201_CREATED,
    )

from django.db import transaction
from django.http import HttpResponse, HttpResponseBadRequest
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_POST
from wajub import WebhookSignatureVerificationError

from .models import SyncDelivery, Vendor
from .tasks import apply_paid_payment
from .wajub import client


def apply_account_event(name, account_id):
    if name == "account.deauthorized":
        Vendor.objects.filter(sync_account_id=account_id).update(
            status="cancelled",
            payment_status="inactive",
        )
        return

    account = client.accounts.retrieve(account_id)

    Vendor.objects.filter(sync_account_id=account_id).update(
        status=account["status"],
        payment_status=account["payment_status"],
    )


@csrf_exempt
@require_POST
def wajub_webhook(request):
    sync = "X-Sync-Event" in request.headers
    signature, timestamp = (
        ("X-Sync-Signature-V1", "X-Sync-Timestamp")
        if sync
        else ("X-Wajub-Signature", "X-Wajub-Timestamp")
    )

    try:
        event = client.webhooks.construct_event(
            request.body,
            request.headers.get(signature, ""),
            request.headers.get(timestamp, ""),
        )
    except WebhookSignatureVerificationError:
        return HttpResponseBadRequest()

    name = event["event"]

    if sync:
        delivery = request.headers.get("X-Idempotency-Key")

        if not delivery:
            return HttpResponseBadRequest()

        with transaction.atomic():
            _, first_time = SyncDelivery.objects.get_or_create(key=delivery)

            if first_time:
                apply_account_event(name, event["account"])

        return HttpResponse(status=200)

    data = event["data"]

    if name.startswith("account."):
        apply_account_event(name, data["account"])

    elif name == "payment.succeeded":
        apply_paid_payment.delay(data["id"])

    return HttpResponse(status=200)

from collections import defaultdict

from django.db import transaction as db_transaction
from rest_framework import status as http
from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from wajub import RequestOptions

from .models import Basket, Order, Vendor
from .wajub import client


@api_view(["POST"])
@permission_classes([IsAuthenticated])
def checkout(request):
    by_vendor = defaultdict(list)

    for line in request.data["items"]:
        by_vendor[line["vendor_id"]].append(line)

    with db_transaction.atomic():
        basket = Basket.objects.create(user=request.user)
        orders = []

        for vendor_id, lines in by_vendor.items():
            vendor = Vendor.objects.get(pk=vendor_id)

            if not vendor.can_sell:
                return Response(
                    {"error": f"{vendor.business_name} cannot take payments yet."},
                    status=http.HTTP_409_CONFLICT,
                )

            orders.append(Order.objects.create(
                basket=basket,
                vendor=vendor,
                amount=price_of(lines),
                currency="XAF",
            ))

    payments = []

    for order in orders:
        payment = client.payments.create(
            {
                "amount": float(order.amount),
                "currency": order.currency,
                "customer": {"email": request.user.email},
                "description": f"{order.vendor.business_name}, basket {basket.id}",
                "reference": f"order-{order.id}",
                "callback": f"https://marketplace.example.com/baskets/{basket.id}/return",
                "metadata": {"basket_id": str(basket.id), "order_id": str(order.id)},
            },
            RequestOptions(
                sync=order.vendor.sync_account_id,
                idempotency_key=f"order-{order.id}",
            ),
        )

        order.payment_id = payment.id
        order.save(update_fields=["payment_id"])

        payments.append({
            "vendor": order.vendor.business_name,
            "amount": order.amount,
            "authorization_url": payment.authorization_url,
        })

    return Response({"basket_id": basket.id, "payments": payments})

client.transfers.create(
    {
        "amount": 45000,
        "currency": "XAF",
        "beneficiary": {
            "name": vendor.business_name,
            "channel": "cm.mtn",
            "phone": vendor.payout_phone,
        },
        "description": "Withdrawal",
    },
    RequestOptions(sync=vendor.sync_account_id),
)

from django.urls import path

from . import checkout, views
from .webhooks import wajub_webhook

urlpatterns = [
    path("vendors/onboard/", views.onboard_vendor, name="vendor-onboard"),
    path("checkout/", checkout.checkout, name="checkout"),
    path("webhooks/wajub/", wajub_webhook, name="wajub-webhook"),
]