:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
"""Deep-link login for the Stripe provisioning namespace.
Owns the browser side of the deep-link primitive end to end - the token minted
by ``DeepLinksView`` is consumed only here, under this namespace's own cache
key. Kept separate from the legacy ``/agentic/login`` route so Stripe does not
depend on the provisioning API's login feature.
The token grants a session with no password or SSO challenge, so
partner-asserted email ownership is the only barrier: an explicitly verified
email (``is_email_verified is True``) is required before a session is created.
"""
from __future__ import annotations
from typing import Any
from django.contrib.auth import login as auth_login
from django.core.cache import cache
from django.http import HttpResponseBase, HttpResponseRedirect
from django.utils.http import urlencode
import structlog
from posthog.api.email_verification import email_verification_code_verifier
from posthog.auth import ACCOUNT_BLOCKED_LOGIN_URL, account_refused
from posthog.exceptions_capture import capture_exception
from posthog.models.team.team import Team
from posthog.models.user import User
from ee.partners.stripe.api.provisioning import DEEP_LINK_CACHE_PREFIX
from ee.partners.stripe.api.provisioning.analytics import capture_provisioning_event
from ee.partners.stripe.api.provisioning.constants import VERIFY_EMAIL_REASON
from ee.partners.stripe.api.provisioning.core import is_safe_deep_link_path
logger = structlog.get_logger(__name__)
def _capture(
outcome: str,
*,
user_id: int | None = None,
team_id: int | None = None,
purpose: str | None = None,
verification_email_sent: bool | None = None,
) -> None:
capture_provisioning_event(
"deep_link_login",
outcome,
user_id=user_id,
team_id=team_id,
purpose=purpose,
verification_email_sent=verification_email_sent,
)
def _block_unverified_email(user: User) -> HttpResponseBase:
"""Send a fresh code and redirect to the verify-email page, telling it why the login stopped."""
email_sent = True
try:
email_verification_code_verifier.send_code(user)
except Exception:
# Intentionally swallowed: the login must stay blocked regardless of email delivery.
# The verifier captures the exception internally; the verify_email page has a resend button.
email_sent = False
logger.warning("stripe_provisioning.login.verification_email_failed", user_id=user.id)
_capture("email_unverified", user_id=user.id, verification_email_sent=email_sent)
logger.warning("stripe_provisioning.login.email_unverified", user_id=user.id, email_sent=email_sent)
params: dict[str, str] = {"reason": VERIFY_EMAIL_REASON}
if not email_sent:
params["email_sent"] = "false"
return HttpResponseRedirect(f"/verify_email/{user.uuid}?{urlencode(params)}")
def _redirect_path(team_id: int | None, path: str | None) -> str:
if path and is_safe_deep_link_path(path):
return path
if path:
# Unreachable in normal operation (mint-time validation already ran); a hit here
# means cache tampering or a mint-side regression.
logger.warning("stripe_provisioning.login.unsafe_path_in_cache", path=path)
if team_id and Team.objects.filter(id=team_id).exists():
return f"/project/{team_id}"
return "/"
def stripe_provisioning_login(request: Any) -> HttpResponseBase:
token = request.GET.get("token", "")
if not token:
_capture("missing_token")
logger.warning("stripe_provisioning.login.missing_token")
return HttpResponseRedirect("/?error=missing_token")
cache_key = f"{DEEP_LINK_CACHE_PREFIX}{token}"
try:
link_data = cache.get(cache_key)
except Exception:
capture_exception(additional_properties={"cache_key": cache_key})
return HttpResponseRedirect("/?error=service_unavailable")
if link_data is None:
_capture("expired_or_invalid_token")
logger.warning("stripe_provisioning.login.expired_or_invalid_token")
return HttpResponseRedirect("/?error=expired_or_invalid_token")
# Atomic delete: if another request already consumed this token, reject.
if not cache.delete(cache_key):
_capture("expired_or_invalid_token")
logger.warning("stripe_provisioning.login.token_already_consumed")
return HttpResponseRedirect("/?error=expired_or_invalid_token")
if not isinstance(link_data, dict):
_capture("invalid_token_data")
logger.warning("stripe_provisioning.login.invalid_token_data")
return HttpResponseRedirect("/?error=invalid_token_data")
user_id = link_data.get("user_id")
team_id = link_data.get("team_id")
purpose = link_data.get("purpose", "dashboard")
path = link_data.get("path")
if not user_id:
_capture("invalid_token_data")
logger.warning("stripe_provisioning.login.missing_user_id")
return HttpResponseRedirect("/?error=invalid_token_data")
try:
user = User.objects.get(id=user_id)
except User.DoesNotExist:
_capture("user_not_found", user_id=user_id)
capture_exception(Exception("Deep link login user not found"), {"user_id": user_id, "team_id": team_id})
return HttpResponseRedirect("/?error=user_not_found")
if not user.is_active:
_capture("user_inactive", user_id=user_id)
logger.warning("stripe_provisioning.login.user_inactive", user_id=user_id)
return HttpResponseRedirect("/?error=user_inactive")
if account_refused(request, user, call_site="stripe_deep_link", impersonated=False):
_capture("access_blocked", user_id=user_id)
return HttpResponseRedirect(ACCOUNT_BLOCKED_LOGIN_URL)
# Deep-link login has no password challenge and no SSO step, so partner-asserted
# email ownership is the only thing standing between an attacker and a session.
# Require explicit is_email_verified=True - don't trust the legacy None passthrough
# or the org-level email-verification-disabled flag.
if user.is_email_verified is not True:
return _block_unverified_email(user)
auth_login(request, user, backend="django.contrib.auth.backends.ModelBackend")
_capture("success", user_id=user_id, team_id=team_id, purpose=purpose)
logger.info("stripe_provisioning.login.success", user_id=user_id, team_id=team_id, purpose=purpose)
return HttpResponseRedirect(_redirect_path(team_id, path))