Samir Boulahtit
0fca762b33
Implement complete marketing homepage for Wizamart targeting Letzshop vendors in Luxembourg. Includes: - Marketing homepage with hero, pricing tiers, and add-ons - 4-step signup wizard with Stripe card collection (30-day trial) - Letzshop vendor lookup for shop claiming - Platform API endpoints for pricing, vendors, and signup - Stripe SetupIntent integration for trial with card upfront - Database fields for Letzshop vendor identity tracking 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
542 lines
16 KiB
Python
542 lines
16 KiB
Python
# app/api/v1/platform/signup.py
|
|
"""
|
|
Platform signup API endpoints.
|
|
|
|
Handles the multi-step signup flow:
|
|
1. Start signup (select tier)
|
|
2. Claim Letzshop vendor (optional)
|
|
3. Create account
|
|
4. Setup payment (collect card via SetupIntent)
|
|
5. Complete signup (create subscription with trial)
|
|
"""
|
|
|
|
import logging
|
|
import secrets
|
|
from datetime import UTC, datetime, timedelta
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException
|
|
from pydantic import BaseModel, EmailStr
|
|
from sqlalchemy.orm import Session
|
|
|
|
from app.core.config import settings
|
|
from app.core.database import get_db
|
|
from app.services.stripe_service import stripe_service
|
|
from models.database.subscription import (
|
|
SubscriptionStatus,
|
|
TierCode,
|
|
VendorSubscription,
|
|
)
|
|
from models.database.vendor import Vendor, VendorUser, VendorUserType
|
|
|
|
router = APIRouter()
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
# =============================================================================
|
|
# In-memory signup session storage (for simplicity)
|
|
# In production, use Redis or database table
|
|
# =============================================================================
|
|
|
|
_signup_sessions: dict[str, dict] = {}
|
|
|
|
|
|
def create_session_id() -> str:
|
|
"""Generate a secure session ID."""
|
|
return secrets.token_urlsafe(32)
|
|
|
|
|
|
def get_session(session_id: str) -> dict | None:
|
|
"""Get a signup session by ID."""
|
|
return _signup_sessions.get(session_id)
|
|
|
|
|
|
def save_session(session_id: str, data: dict) -> None:
|
|
"""Save signup session data."""
|
|
_signup_sessions[session_id] = {
|
|
**data,
|
|
"updated_at": datetime.now(UTC).isoformat(),
|
|
}
|
|
|
|
|
|
def delete_session(session_id: str) -> None:
|
|
"""Delete a signup session."""
|
|
_signup_sessions.pop(session_id, None)
|
|
|
|
|
|
# =============================================================================
|
|
# Request/Response Schemas
|
|
# =============================================================================
|
|
|
|
|
|
class SignupStartRequest(BaseModel):
|
|
"""Start signup - select tier."""
|
|
|
|
tier_code: str
|
|
is_annual: bool = False
|
|
|
|
|
|
class SignupStartResponse(BaseModel):
|
|
"""Response from signup start."""
|
|
|
|
session_id: str
|
|
tier_code: str
|
|
is_annual: bool
|
|
|
|
|
|
class ClaimVendorRequest(BaseModel):
|
|
"""Claim Letzshop vendor."""
|
|
|
|
session_id: str
|
|
letzshop_slug: str
|
|
letzshop_vendor_id: str | None = None
|
|
|
|
|
|
class ClaimVendorResponse(BaseModel):
|
|
"""Response from vendor claim."""
|
|
|
|
session_id: str
|
|
letzshop_slug: str
|
|
vendor_name: str | None
|
|
|
|
|
|
class CreateAccountRequest(BaseModel):
|
|
"""Create account."""
|
|
|
|
session_id: str
|
|
email: EmailStr
|
|
password: str
|
|
first_name: str
|
|
last_name: str
|
|
company_name: str
|
|
phone: str | None = None
|
|
|
|
|
|
class CreateAccountResponse(BaseModel):
|
|
"""Response from account creation."""
|
|
|
|
session_id: str
|
|
user_id: int
|
|
vendor_id: int
|
|
stripe_customer_id: str
|
|
|
|
|
|
class SetupPaymentRequest(BaseModel):
|
|
"""Request payment setup."""
|
|
|
|
session_id: str
|
|
|
|
|
|
class SetupPaymentResponse(BaseModel):
|
|
"""Response with Stripe SetupIntent client secret."""
|
|
|
|
session_id: str
|
|
client_secret: str
|
|
stripe_customer_id: str
|
|
|
|
|
|
class CompleteSignupRequest(BaseModel):
|
|
"""Complete signup after card collection."""
|
|
|
|
session_id: str
|
|
setup_intent_id: str
|
|
|
|
|
|
class CompleteSignupResponse(BaseModel):
|
|
"""Response from signup completion."""
|
|
|
|
success: bool
|
|
vendor_code: str
|
|
vendor_id: int
|
|
redirect_url: str
|
|
trial_ends_at: str
|
|
|
|
|
|
# =============================================================================
|
|
# Endpoints
|
|
# =============================================================================
|
|
|
|
|
|
@router.post("/signup/start", response_model=SignupStartResponse)
|
|
async def start_signup(
|
|
request: SignupStartRequest,
|
|
db: Session = Depends(get_db),
|
|
) -> SignupStartResponse:
|
|
"""
|
|
Start the signup process.
|
|
|
|
Step 1: User selects a tier and billing period.
|
|
Creates a signup session to track the flow.
|
|
"""
|
|
# Validate tier code
|
|
try:
|
|
tier = TierCode(request.tier_code)
|
|
except ValueError:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail=f"Invalid tier code: {request.tier_code}",
|
|
)
|
|
|
|
# Create session
|
|
session_id = create_session_id()
|
|
save_session(session_id, {
|
|
"step": "tier_selected",
|
|
"tier_code": tier.value,
|
|
"is_annual": request.is_annual,
|
|
"created_at": datetime.now(UTC).isoformat(),
|
|
})
|
|
|
|
logger.info(f"Started signup session {session_id} for tier {tier.value}")
|
|
|
|
return SignupStartResponse(
|
|
session_id=session_id,
|
|
tier_code=tier.value,
|
|
is_annual=request.is_annual,
|
|
)
|
|
|
|
|
|
@router.post("/signup/claim-vendor", response_model=ClaimVendorResponse)
|
|
async def claim_letzshop_vendor(
|
|
request: ClaimVendorRequest,
|
|
db: Session = Depends(get_db),
|
|
) -> ClaimVendorResponse:
|
|
"""
|
|
Claim a Letzshop vendor.
|
|
|
|
Step 2 (optional): User claims their Letzshop shop.
|
|
This pre-fills vendor info during account creation.
|
|
"""
|
|
session = get_session(request.session_id)
|
|
if not session:
|
|
raise HTTPException(status_code=404, detail="Signup session not found")
|
|
|
|
# Check if vendor is already claimed
|
|
existing = db.query(Vendor).filter(
|
|
Vendor.letzshop_vendor_slug == request.letzshop_slug,
|
|
Vendor.is_active == True,
|
|
).first()
|
|
|
|
if existing:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail="This Letzshop vendor is already claimed",
|
|
)
|
|
|
|
# Update session with vendor info
|
|
session["letzshop_slug"] = request.letzshop_slug
|
|
session["letzshop_vendor_id"] = request.letzshop_vendor_id
|
|
session["step"] = "vendor_claimed"
|
|
|
|
# TODO: Fetch actual vendor name from Letzshop API
|
|
vendor_name = request.letzshop_slug.replace("-", " ").title()
|
|
session["vendor_name"] = vendor_name
|
|
|
|
save_session(request.session_id, session)
|
|
|
|
logger.info(f"Claimed vendor {request.letzshop_slug} for session {request.session_id}")
|
|
|
|
return ClaimVendorResponse(
|
|
session_id=request.session_id,
|
|
letzshop_slug=request.letzshop_slug,
|
|
vendor_name=vendor_name,
|
|
)
|
|
|
|
|
|
@router.post("/signup/create-account", response_model=CreateAccountResponse)
|
|
async def create_account(
|
|
request: CreateAccountRequest,
|
|
db: Session = Depends(get_db),
|
|
) -> CreateAccountResponse:
|
|
"""
|
|
Create user and vendor accounts.
|
|
|
|
Step 3: User provides account details.
|
|
Creates User, Company, Vendor, and Stripe Customer.
|
|
"""
|
|
session = get_session(request.session_id)
|
|
if not session:
|
|
raise HTTPException(status_code=404, detail="Signup session not found")
|
|
|
|
# Check if email already exists
|
|
from models.database.user import User
|
|
|
|
existing_user = db.query(User).filter(User.email == request.email).first()
|
|
if existing_user:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail="An account with this email already exists",
|
|
)
|
|
|
|
try:
|
|
# Create Company
|
|
from models.database.company import Company
|
|
|
|
company = Company(
|
|
name=request.company_name,
|
|
contact_email=request.email,
|
|
contact_phone=request.phone,
|
|
)
|
|
db.add(company)
|
|
db.flush()
|
|
|
|
# Create User
|
|
from app.core.security import get_password_hash
|
|
|
|
user = User(
|
|
email=request.email,
|
|
hashed_password=get_password_hash(request.password),
|
|
first_name=request.first_name,
|
|
last_name=request.last_name,
|
|
is_active=True,
|
|
)
|
|
db.add(user)
|
|
db.flush()
|
|
|
|
# Generate vendor code
|
|
vendor_code = request.company_name.upper().replace(" ", "_")[:20]
|
|
# Ensure unique
|
|
base_code = vendor_code
|
|
counter = 1
|
|
while db.query(Vendor).filter(Vendor.vendor_code == vendor_code).first():
|
|
vendor_code = f"{base_code}_{counter}"
|
|
counter += 1
|
|
|
|
# Generate subdomain
|
|
subdomain = request.company_name.lower().replace(" ", "-")
|
|
subdomain = "".join(c for c in subdomain if c.isalnum() or c == "-")[:50]
|
|
base_subdomain = subdomain
|
|
counter = 1
|
|
while db.query(Vendor).filter(Vendor.subdomain == subdomain).first():
|
|
subdomain = f"{base_subdomain}-{counter}"
|
|
counter += 1
|
|
|
|
# Create Vendor
|
|
vendor = Vendor(
|
|
company_id=company.id,
|
|
vendor_code=vendor_code,
|
|
subdomain=subdomain,
|
|
name=request.company_name,
|
|
contact_email=request.email,
|
|
contact_phone=request.phone,
|
|
is_active=True,
|
|
letzshop_vendor_slug=session.get("letzshop_slug"),
|
|
letzshop_vendor_id=session.get("letzshop_vendor_id"),
|
|
)
|
|
db.add(vendor)
|
|
db.flush()
|
|
|
|
# Create VendorUser (owner)
|
|
vendor_user = VendorUser(
|
|
vendor_id=vendor.id,
|
|
user_id=user.id,
|
|
user_type=VendorUserType.OWNER.value,
|
|
is_active=True,
|
|
)
|
|
db.add(vendor_user)
|
|
|
|
# Create Stripe Customer
|
|
stripe_customer_id = stripe_service.create_customer(
|
|
vendor=vendor,
|
|
email=request.email,
|
|
name=f"{request.first_name} {request.last_name}",
|
|
metadata={
|
|
"company_name": request.company_name,
|
|
"tier": session.get("tier_code"),
|
|
},
|
|
)
|
|
|
|
# Create VendorSubscription (in trial status, without Stripe subscription yet)
|
|
now = datetime.now(UTC)
|
|
trial_end = now + timedelta(days=settings.stripe_trial_days)
|
|
|
|
subscription = VendorSubscription(
|
|
vendor_id=vendor.id,
|
|
tier=session.get("tier_code", TierCode.ESSENTIAL.value),
|
|
status=SubscriptionStatus.TRIAL.value,
|
|
period_start=now,
|
|
period_end=trial_end,
|
|
trial_ends_at=trial_end,
|
|
is_annual=session.get("is_annual", False),
|
|
stripe_customer_id=stripe_customer_id,
|
|
)
|
|
db.add(subscription)
|
|
|
|
db.commit()
|
|
|
|
# Update session
|
|
session["user_id"] = user.id
|
|
session["vendor_id"] = vendor.id
|
|
session["vendor_code"] = vendor_code
|
|
session["stripe_customer_id"] = stripe_customer_id
|
|
session["step"] = "account_created"
|
|
save_session(request.session_id, session)
|
|
|
|
logger.info(
|
|
f"Created account for {request.email}: "
|
|
f"user_id={user.id}, vendor_id={vendor.id}"
|
|
)
|
|
|
|
return CreateAccountResponse(
|
|
session_id=request.session_id,
|
|
user_id=user.id,
|
|
vendor_id=vendor.id,
|
|
stripe_customer_id=stripe_customer_id,
|
|
)
|
|
|
|
except Exception as e:
|
|
db.rollback()
|
|
logger.error(f"Error creating account: {e}")
|
|
raise HTTPException(status_code=500, detail="Failed to create account")
|
|
|
|
|
|
@router.post("/signup/setup-payment", response_model=SetupPaymentResponse)
|
|
async def setup_payment(
|
|
request: SetupPaymentRequest,
|
|
db: Session = Depends(get_db),
|
|
) -> SetupPaymentResponse:
|
|
"""
|
|
Create Stripe SetupIntent for card collection.
|
|
|
|
Step 4: Collect card details without charging.
|
|
The card will be charged after the trial period ends.
|
|
"""
|
|
session = get_session(request.session_id)
|
|
if not session:
|
|
raise HTTPException(status_code=404, detail="Signup session not found")
|
|
|
|
if "stripe_customer_id" not in session:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail="Account not created. Please complete step 3 first.",
|
|
)
|
|
|
|
stripe_customer_id = session["stripe_customer_id"]
|
|
|
|
# Create SetupIntent
|
|
setup_intent = stripe_service.create_setup_intent(
|
|
customer_id=stripe_customer_id,
|
|
metadata={
|
|
"session_id": request.session_id,
|
|
"vendor_id": str(session.get("vendor_id")),
|
|
"tier": session.get("tier_code"),
|
|
},
|
|
)
|
|
|
|
# Update session
|
|
session["setup_intent_id"] = setup_intent.id
|
|
session["step"] = "payment_pending"
|
|
save_session(request.session_id, session)
|
|
|
|
logger.info(f"Created SetupIntent {setup_intent.id} for session {request.session_id}")
|
|
|
|
return SetupPaymentResponse(
|
|
session_id=request.session_id,
|
|
client_secret=setup_intent.client_secret,
|
|
stripe_customer_id=stripe_customer_id,
|
|
)
|
|
|
|
|
|
@router.post("/signup/complete", response_model=CompleteSignupResponse)
|
|
async def complete_signup(
|
|
request: CompleteSignupRequest,
|
|
db: Session = Depends(get_db),
|
|
) -> CompleteSignupResponse:
|
|
"""
|
|
Complete signup after card collection.
|
|
|
|
Step 5: Verify SetupIntent, attach payment method, create subscription.
|
|
"""
|
|
session = get_session(request.session_id)
|
|
if not session:
|
|
raise HTTPException(status_code=404, detail="Signup session not found")
|
|
|
|
vendor_id = session.get("vendor_id")
|
|
stripe_customer_id = session.get("stripe_customer_id")
|
|
|
|
if not vendor_id or not stripe_customer_id:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail="Incomplete signup. Please start again.",
|
|
)
|
|
|
|
try:
|
|
# Retrieve SetupIntent to get payment method
|
|
setup_intent = stripe_service.get_setup_intent(request.setup_intent_id)
|
|
|
|
if setup_intent.status != "succeeded":
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail="Card setup not completed. Please try again.",
|
|
)
|
|
|
|
payment_method_id = setup_intent.payment_method
|
|
|
|
# Attach payment method to customer
|
|
stripe_service.attach_payment_method_to_customer(
|
|
customer_id=stripe_customer_id,
|
|
payment_method_id=payment_method_id,
|
|
set_as_default=True,
|
|
)
|
|
|
|
# Update subscription record with card collection time
|
|
subscription = (
|
|
db.query(VendorSubscription)
|
|
.filter(VendorSubscription.vendor_id == vendor_id)
|
|
.first()
|
|
)
|
|
|
|
if subscription:
|
|
subscription.card_collected_at = datetime.now(UTC)
|
|
subscription.stripe_payment_method_id = payment_method_id
|
|
|
|
# TODO: Create actual Stripe subscription with trial
|
|
# For now, just mark as trial with card collected
|
|
|
|
db.commit()
|
|
|
|
vendor = db.query(Vendor).filter(Vendor.id == vendor_id).first()
|
|
vendor_code = vendor.vendor_code if vendor else session.get("vendor_code")
|
|
|
|
# Clean up session
|
|
delete_session(request.session_id)
|
|
|
|
trial_ends_at = subscription.trial_ends_at if subscription else datetime.now(UTC) + timedelta(days=30)
|
|
|
|
logger.info(f"Completed signup for vendor {vendor_id}")
|
|
|
|
return CompleteSignupResponse(
|
|
success=True,
|
|
vendor_code=vendor_code,
|
|
vendor_id=vendor_id,
|
|
redirect_url=f"/vendors/{vendor_code}/dashboard",
|
|
trial_ends_at=trial_ends_at.isoformat(),
|
|
)
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error completing signup: {e}")
|
|
raise HTTPException(status_code=500, detail="Failed to complete signup")
|
|
|
|
|
|
@router.get("/signup/session/{session_id}")
|
|
async def get_signup_session(session_id: str) -> dict:
|
|
"""
|
|
Get signup session status.
|
|
|
|
Useful for resuming an incomplete signup.
|
|
"""
|
|
session = get_session(session_id)
|
|
if not session:
|
|
raise HTTPException(status_code=404, detail="Session not found")
|
|
|
|
# Return safe subset of session data
|
|
return {
|
|
"session_id": session_id,
|
|
"step": session.get("step"),
|
|
"tier_code": session.get("tier_code"),
|
|
"is_annual": session.get("is_annual"),
|
|
"letzshop_slug": session.get("letzshop_slug"),
|
|
"vendor_name": session.get("vendor_name"),
|
|
"created_at": session.get("created_at"),
|
|
}
|