Giorgio Gilestro
410afe0078
Stripe is the merchant-on-record for read.markets after Polar/Paddle
both declined the financial-media category. This commit lands the
full subscription flow: an "Upgrade" button on /pricing now opens a
real Stripe-hosted Checkout, completes the subscription, and the
webhook flips user.tier to "paid" idempotently.
Endpoints
- POST /api/stripe/checkout (require_auth) — creates a hosted
Checkout Session in subscription mode, passes user.id as
client_reference_id + email as customer_email, returns the URL
for the page-side JS to redirect to. Reuses an existing
stripe_customer_id to avoid duplicate Stripe customers on repeat
checkouts. allow_promotion_codes=True so the referral-credit
redemption can attach a coupon at checkout once that flow ships.
- POST /api/stripe/portal (require_auth) — mints a Stripe Customer
Portal session. Used by /settings; returns 404 until the user has
a stripe_customer_id (i.e. completed at least one checkout).
- POST /api/stripe/webhook — signature-verified via
stripe.Webhook.construct_event. Idempotent via UNIQUE on
stripe_events.event_id. Event dispatch:
checkout.session.completed → grant paid, store IDs
customer.subscription.created → grant paid (active/trialing)
customer.subscription.updated → grant paid (active/trialing)
customer.subscription.deleted → drop to free, clear sub id
invoice.paid / failed → audit only
charge.refunded → audit only
Stripe-SDK objects don't expose dict.get(); we use the SDK for
signature verification then re-parse the JSON body for handler
dispatch — cleaner than reaching into StripeObject internals.
Schema (migration 0019)
- users.stripe_customer_id, users.stripe_subscription_id (nullable
String(64), UNIQUE on customer_id).
- stripe_events table mirroring polar_events: event_id (unique),
event_type, received_at, processed_at, error, raw payload
(truncated to 16 KiB).
Settings (.env)
- STRIPE_API_KEY (rk_test_… for dev, rk_live_… for GA)
- STRIPE_WEBHOOK_SECRET (whsec_… from the dashboard endpoint)
- STRIPE_PRICE_MONTHLY (price_xxx for £7/month)
- STRIPE_PRICE_ANNUAL (price_xxx for £70/year)
Pricing page
- Free tier CTA unchanged.
- Paid CTA branches three ways: paid → "Manage subscription" to
/settings; logged-in free → two buttons (£7/mo, £70/yr) that POST
to /api/stripe/checkout and redirect; anonymous → /login?next=/pricing.
- Inline JS intercepts the button click, calls the checkout
endpoint, redirects on success, surfaces errors via alert(). No
Stripe.js dep — we use the hosted-checkout URL directly.
Polar handler stays in place for berengar.io / flyroom.net which
still ship through Polar. polar_* and stripe_* columns coexist
independently on the User row.
Tests
- 9 in tests/test_stripe_billing.py covering: bad signature → 401,
missing signature → 400, checkout.session.completed flips tier +
stores IDs, subscription.updated active grants paid,
subscription.deleted drops to free with customer id preserved,
replayed event id is no-op (one row in stripe_events),
unknown event acked 200, checkout endpoint mocks the SDK and
returns the hosted URL, checkout requires login.
- Full suite: 221 passed, 5 skipped.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
71 lines
2.2 KiB
Python
71 lines
2.2 KiB
Python
"""Unauthenticated marketing + legal pages.
|
|
|
|
This router carries no auth dependency — every route is reachable to
|
|
anonymous visitors and is also reachable to logged-in users (the
|
|
templates branch off `cu` to flip the top-right CTA between
|
|
"Sign in / sign up" and "Dashboard").
|
|
|
|
The dual-purpose root (`/`) lives in `app/routers/pages.py` because it
|
|
also has to render the dashboard when authenticated. Pure public-only
|
|
pages live here.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from fastapi import APIRouter, Depends, Request
|
|
from fastapi.responses import HTMLResponse
|
|
|
|
from app.auth import CurrentUser, maybe_current_user
|
|
from app.services.access import is_paid_active
|
|
from app.templates_env import templates
|
|
|
|
|
|
router = APIRouter(tags=["public"])
|
|
|
|
|
|
def _ctx(request: Request, cu: CurrentUser | None) -> dict:
|
|
"""Minimal context every public template expects. `cu` is injected
|
|
into the template so the header CTA can flip between
|
|
'Sign in / sign up' and 'Dashboard'."""
|
|
return {"cu": cu}
|
|
|
|
|
|
@router.get("/pricing", response_class=HTMLResponse)
|
|
async def pricing_page(
|
|
request: Request,
|
|
cu: CurrentUser | None = Depends(maybe_current_user),
|
|
):
|
|
ctx = _ctx(request, cu)
|
|
ctx["paid"] = is_paid_active(cu)
|
|
return templates.TemplateResponse(request, "pricing.html", ctx)
|
|
|
|
|
|
@router.get("/about", response_class=HTMLResponse)
|
|
async def about_page(
|
|
request: Request,
|
|
cu: CurrentUser | None = Depends(maybe_current_user),
|
|
):
|
|
return templates.TemplateResponse(request, "about.html", _ctx(request, cu))
|
|
|
|
|
|
@router.get("/terms", response_class=HTMLResponse)
|
|
async def terms_page(
|
|
request: Request,
|
|
cu: CurrentUser | None = Depends(maybe_current_user),
|
|
):
|
|
return templates.TemplateResponse(request, "terms.html", _ctx(request, cu))
|
|
|
|
|
|
@router.get("/privacy", response_class=HTMLResponse)
|
|
async def privacy_page(
|
|
request: Request,
|
|
cu: CurrentUser | None = Depends(maybe_current_user),
|
|
):
|
|
return templates.TemplateResponse(request, "privacy.html", _ctx(request, cu))
|
|
|
|
|
|
@router.get("/disclaimer", response_class=HTMLResponse)
|
|
async def disclaimer_page(
|
|
request: Request,
|
|
cu: CurrentUser | None = Depends(maybe_current_user),
|
|
):
|
|
return templates.TemplateResponse(request, "disclaimer.html", _ctx(request, cu))
|