westfarn
a6c45b0882
Implements #16/#17/#36: Founders/Standard/Pro/Business/Backer catalog, Backer email whitelist, prompt-window + token-period gates, and tokens_in/out on conversation/prompt + subscription usage APIs.
255 lines
8.5 KiB
Python
255 lines
8.5 KiB
Python
import logging
|
|
|
|
import stripe
|
|
from django.conf import settings
|
|
from rest_framework import permissions, status
|
|
from rest_framework.response import Response
|
|
from rest_framework.views import APIView
|
|
|
|
from finance.models import Invoice, Payment, SubscriptionPlan, UserSubscription
|
|
from finance.serializers import (
|
|
CheckoutSessionSerializer,
|
|
InvoiceSerializer,
|
|
PaymentSerializer,
|
|
PortalSessionSerializer,
|
|
SubscriptionPlanSerializer,
|
|
)
|
|
from finance.services.plans import (
|
|
needs_checkout,
|
|
plan_to_dict,
|
|
seed_subscription_plans,
|
|
)
|
|
from finance.services.quotas import get_usage_snapshot
|
|
from finance.services.stripe_service import (
|
|
StripeNotConfiguredError,
|
|
create_billing_portal_session,
|
|
create_checkout_session,
|
|
resolve_stripe_customer_id,
|
|
)
|
|
from finance.services.webhooks import dispatch_stripe_event
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class CreateCheckoutSessionView(APIView):
|
|
"""Create a Stripe Checkout Session and return the hosted redirect URL."""
|
|
|
|
def post(self, request):
|
|
serializer = CheckoutSessionSerializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
|
|
try:
|
|
sub = request.user.subscription
|
|
except UserSubscription.DoesNotExist:
|
|
sub = None
|
|
if (
|
|
sub is not None
|
|
and sub.is_active
|
|
and sub.source == UserSubscription.Source.BACKER
|
|
):
|
|
return Response(
|
|
{
|
|
"detail": (
|
|
"This account has complimentary Backer access and "
|
|
"does not require payment."
|
|
),
|
|
"needs_checkout": False,
|
|
},
|
|
status=status.HTTP_400_BAD_REQUEST,
|
|
)
|
|
|
|
try:
|
|
session, plan = create_checkout_session(
|
|
user=request.user,
|
|
success_url=serializer.validated_data.get("success_url"),
|
|
cancel_url=serializer.validated_data.get("cancel_url"),
|
|
plan_slug=serializer.validated_data.get("plan_slug"),
|
|
)
|
|
except ValueError as exc:
|
|
return Response({"detail": str(exc)}, status=status.HTTP_400_BAD_REQUEST)
|
|
except StripeNotConfiguredError as exc:
|
|
return Response(
|
|
{"detail": str(exc)},
|
|
status=status.HTTP_503_SERVICE_UNAVAILABLE,
|
|
)
|
|
except stripe.StripeError as exc:
|
|
logger.exception("Stripe Checkout Session creation failed")
|
|
return Response(
|
|
{"detail": str(getattr(exc, "user_message", None) or exc)},
|
|
status=status.HTTP_502_BAD_GATEWAY,
|
|
)
|
|
|
|
# Persist a draft invoice keyed by checkout session for admin visibility
|
|
# before the webhook fires.
|
|
Invoice.objects.update_or_create(
|
|
stripe_checkout_session_id=session.id,
|
|
defaults={
|
|
"user": request.user,
|
|
"company": request.user.company,
|
|
"provider": Invoice.Provider.STRIPE,
|
|
"status": Invoice.Status.OPEN,
|
|
"currency": plan.currency or settings.SUBSCRIPTION_PRICE_CURRENCY,
|
|
"amount_due": plan.price_cents,
|
|
"amount_paid": 0,
|
|
"stripe_customer_id": getattr(session, "customer", None) or "",
|
|
"description": plan.name,
|
|
},
|
|
)
|
|
|
|
return Response(
|
|
{
|
|
"checkout_url": session.url,
|
|
"session_id": session.id,
|
|
"plan_slug": plan.slug,
|
|
},
|
|
status=status.HTTP_201_CREATED,
|
|
)
|
|
|
|
|
|
class CreateBillingPortalSessionView(APIView):
|
|
"""Create a Stripe Customer Portal session and return the hosted URL."""
|
|
|
|
def post(self, request):
|
|
serializer = PortalSessionSerializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
|
|
customer_id = resolve_stripe_customer_id(user=request.user)
|
|
if not customer_id:
|
|
return Response(
|
|
{
|
|
"detail": (
|
|
"No Stripe customer found for this account. "
|
|
"Complete Checkout first to manage billing."
|
|
)
|
|
},
|
|
status=status.HTTP_400_BAD_REQUEST,
|
|
)
|
|
|
|
try:
|
|
session = create_billing_portal_session(
|
|
customer_id=customer_id,
|
|
return_url=serializer.validated_data.get("return_url"),
|
|
)
|
|
except StripeNotConfiguredError as exc:
|
|
return Response(
|
|
{"detail": str(exc)},
|
|
status=status.HTTP_503_SERVICE_UNAVAILABLE,
|
|
)
|
|
except stripe.StripeError as exc:
|
|
logger.exception("Stripe Billing Portal Session creation failed")
|
|
return Response(
|
|
{"detail": str(getattr(exc, "user_message", None) or exc)},
|
|
status=status.HTTP_502_BAD_GATEWAY,
|
|
)
|
|
|
|
return Response(
|
|
{"portal_url": session.url},
|
|
status=status.HTTP_201_CREATED,
|
|
)
|
|
|
|
|
|
class InvoiceListView(APIView):
|
|
def get(self, request):
|
|
invoices = Invoice.objects.filter(user=request.user)
|
|
return Response(InvoiceSerializer(invoices, many=True).data)
|
|
|
|
|
|
class PaymentListView(APIView):
|
|
def get(self, request):
|
|
payments = Payment.objects.filter(user=request.user)
|
|
return Response(PaymentSerializer(payments, many=True).data)
|
|
|
|
|
|
class PlanListView(APIView):
|
|
"""Public-facing plan catalog (only `is_public` rows by default)."""
|
|
|
|
permission_classes = (permissions.AllowAny,)
|
|
authentication_classes = ()
|
|
|
|
def get(self, request):
|
|
seed_subscription_plans(update_existing=False)
|
|
include_all = (
|
|
request.user
|
|
and request.user.is_authenticated
|
|
and request.user.is_staff
|
|
and request.query_params.get("all") == "1"
|
|
)
|
|
qs = SubscriptionPlan.objects.all()
|
|
if not include_all:
|
|
qs = qs.filter(is_public=True)
|
|
return Response(SubscriptionPlanSerializer(qs, many=True).data)
|
|
|
|
|
|
class SubscriptionMeView(APIView):
|
|
"""Current user's plan, checkout need, and usage snapshot (#16/#17/#36)."""
|
|
|
|
def get(self, request):
|
|
seed_subscription_plans(update_existing=False)
|
|
try:
|
|
sub = request.user.subscription
|
|
except UserSubscription.DoesNotExist:
|
|
sub = None
|
|
|
|
usage = get_usage_snapshot(request.user)
|
|
payload = {
|
|
"plan": plan_to_dict(sub.plan) if sub and sub.plan_id else None,
|
|
"status": sub.status if sub else UserSubscription.Status.NONE,
|
|
"source": sub.source if sub else UserSubscription.Source.NONE,
|
|
"needs_checkout": needs_checkout(request.user),
|
|
"stripe_subscription_id": (
|
|
sub.stripe_subscription_id if sub else ""
|
|
),
|
|
"usage": usage.to_dict(),
|
|
}
|
|
return Response(payload)
|
|
|
|
|
|
class StripeWebhookView(APIView):
|
|
"""Verify Stripe signatures and upsert local invoice/payment rows."""
|
|
|
|
permission_classes = (permissions.AllowAny,)
|
|
authentication_classes = ()
|
|
|
|
def post(self, request):
|
|
payload = request.body
|
|
sig_header = request.META.get("HTTP_STRIPE_SIGNATURE", "")
|
|
webhook_secret = settings.STRIPE_WEBHOOK_SECRET
|
|
|
|
if not webhook_secret:
|
|
logger.error("STRIPE_WEBHOOK_SECRET is not configured")
|
|
return Response(
|
|
{"detail": "Webhook secret not configured"},
|
|
status=status.HTTP_503_SERVICE_UNAVAILABLE,
|
|
)
|
|
|
|
try:
|
|
event = stripe.Webhook.construct_event(
|
|
payload=payload,
|
|
sig_header=sig_header,
|
|
secret=webhook_secret,
|
|
)
|
|
except ValueError:
|
|
return Response(
|
|
{"detail": "Invalid payload"},
|
|
status=status.HTTP_400_BAD_REQUEST,
|
|
)
|
|
except stripe.SignatureVerificationError:
|
|
return Response(
|
|
{"detail": "Invalid signature"},
|
|
status=status.HTTP_400_BAD_REQUEST,
|
|
)
|
|
|
|
if hasattr(event, "to_dict"):
|
|
event = event.to_dict()
|
|
|
|
try:
|
|
dispatch_stripe_event(event)
|
|
except Exception:
|
|
logger.exception("Error handling Stripe event %s", event.get("id"))
|
|
return Response(
|
|
{"detail": "Webhook handler error"},
|
|
status=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
)
|
|
|
|
return Response({"received": True}, status=status.HTTP_200_OK)
|