1f0dcb1ddb
- Frontend: Next.js 14 with TypeScript - Backend: FastAPI with SQLAlchemy - Agent: Carmodoo sync agent - Deployment: Docker Compose based staging/production setup - Scripts: Automated deployment with rollback support 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
887 lines
30 KiB
Python
887 lines
30 KiB
Python
from fastapi import APIRouter, Depends, HTTPException, Request, Header
|
|
from sqlalchemy.orm import Session
|
|
from sqlalchemy import desc
|
|
from typing import List, Optional
|
|
from pydantic import BaseModel
|
|
from datetime import datetime
|
|
import stripe
|
|
import logging
|
|
|
|
from ..database import get_db
|
|
from ..models import User, Car, CarView, PerformanceCheckView, ChargeHistory, CarPerformanceCheck, CCPackage, DEFAULT_CC_PACKAGES
|
|
from ..models.settings import SystemSettings
|
|
from ..models.user import PaymentSettings
|
|
from ..schemas import UserResponse, CarViewResponse, PurchaseViewRequest
|
|
from .auth import get_current_user, get_current_admin_user, get_current_user_optional
|
|
from .referral import create_referral_reward
|
|
from .carmodoo import CarmodooClient, capture_performance_check_pdf
|
|
from .notification import notify_system
|
|
from ..config import get_settings
|
|
|
|
logger = logging.getLogger(__name__)
|
|
settings = get_settings()
|
|
|
|
# Configure Stripe
|
|
stripe.api_key = settings.STRIPE_SECRET_KEY
|
|
|
|
router = APIRouter(prefix="/cc", tags=["cc"])
|
|
|
|
|
|
class ChargeRequest(BaseModel):
|
|
amount: int
|
|
currency: str = "USD"
|
|
payment_method: str = "card"
|
|
transaction_id: Optional[str] = None # For crypto payments
|
|
wallet_address: Optional[str] = None # User's wallet for refunds
|
|
|
|
|
|
class USDCChargeRequest(BaseModel):
|
|
amount_usdc: int
|
|
transaction_hash: str
|
|
wallet_address: str
|
|
network: str = "Polygon"
|
|
|
|
|
|
class ChargeHistoryResponse(BaseModel):
|
|
id: int
|
|
amount_usd: int
|
|
cc_amount: int
|
|
payment_method: str
|
|
status: str
|
|
created_at: str
|
|
|
|
class Config:
|
|
from_attributes = True
|
|
|
|
|
|
@router.get("/balance")
|
|
def get_cc_balance(current_user: User = Depends(get_current_user)):
|
|
"""Get current user's CC balance"""
|
|
return {"cc_balance": current_user.cc_balance or 0}
|
|
|
|
|
|
@router.get("/views", response_model=List[CarViewResponse])
|
|
def get_purchased_views(
|
|
current_user: User = Depends(get_current_user),
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""Get list of cars the user has paid to view"""
|
|
views = db.query(CarView).filter(CarView.user_id == current_user.id).all()
|
|
return views
|
|
|
|
|
|
@router.get("/views/car-ids")
|
|
def get_purchased_car_ids(
|
|
current_user: User = Depends(get_current_user),
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""Get list of car IDs the user has paid to view (for quick lookup)"""
|
|
views = db.query(CarView.car_id).filter(CarView.user_id == current_user.id).all()
|
|
return {"car_ids": [v[0] for v in views]}
|
|
|
|
|
|
@router.post("/purchase-view")
|
|
def purchase_car_view(
|
|
request: PurchaseViewRequest,
|
|
current_user: User = Depends(get_current_user),
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""Purchase access to view full car details (costs 1 CC)"""
|
|
car_id = request.car_id
|
|
|
|
# Check if car exists
|
|
car = db.query(Car).filter(Car.id == car_id).first()
|
|
if not car:
|
|
raise HTTPException(status_code=404, detail="Car not found")
|
|
|
|
# Check if already purchased
|
|
existing_view = db.query(CarView).filter(
|
|
CarView.user_id == current_user.id,
|
|
CarView.car_id == car_id
|
|
).first()
|
|
|
|
if existing_view:
|
|
return {"message": "Already purchased", "cc_balance": current_user.cc_balance}
|
|
|
|
# Check if user has enough CC
|
|
if (current_user.cc_balance or 0) < 1:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail="Insufficient CC balance. You need 1 CC to view full car details."
|
|
)
|
|
|
|
# Deduct CC and create view record
|
|
current_user.cc_balance = (current_user.cc_balance or 0) - 1
|
|
|
|
car_view = CarView(
|
|
user_id=current_user.id,
|
|
car_id=car_id,
|
|
cc_paid=1
|
|
)
|
|
db.add(car_view)
|
|
db.commit()
|
|
|
|
return {
|
|
"message": "Purchase successful",
|
|
"cc_balance": current_user.cc_balance,
|
|
"car_id": car_id
|
|
}
|
|
|
|
|
|
@router.get("/check-view/{car_id}")
|
|
def check_car_view(
|
|
car_id: int,
|
|
current_user: User = Depends(get_current_user),
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""Check if user has purchased view access for a specific car"""
|
|
existing_view = db.query(CarView).filter(
|
|
CarView.user_id == current_user.id,
|
|
CarView.car_id == car_id
|
|
).first()
|
|
|
|
return {
|
|
"has_access": existing_view is not None,
|
|
"cc_balance": current_user.cc_balance or 0
|
|
}
|
|
|
|
|
|
PERFORMANCE_CHECK_COST = 0.1 # 0.1 CC for performance check view
|
|
|
|
|
|
@router.post("/purchase-performance-check")
|
|
async def purchase_performance_check_view(
|
|
request: PurchaseViewRequest,
|
|
current_user: User = Depends(get_current_user),
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""Purchase access to view performance check (costs 0.1 CC)"""
|
|
car_id = request.car_id
|
|
|
|
# Check if car exists
|
|
car = db.query(Car).filter(Car.id == car_id).first()
|
|
if not car:
|
|
raise HTTPException(status_code=404, detail="Car not found")
|
|
|
|
# Check if performance check record exists
|
|
perf_check = db.query(CarPerformanceCheck).filter(
|
|
CarPerformanceCheck.car_id == car_id
|
|
).first()
|
|
|
|
# If no performance check record, try to fetch from Carmodoo
|
|
if not perf_check:
|
|
try:
|
|
carmodoo_client = CarmodooClient()
|
|
check_num = car.check_num or ""
|
|
|
|
# Try to get check_num if not available
|
|
if not check_num:
|
|
check_num = await carmodoo_client.get_car_check_num(car.source_id, car.source_key or "")
|
|
|
|
if check_num:
|
|
# Fetch performance check data
|
|
perf_result = await carmodoo_client.get_performance_check(car.source_id, car.source_key or "", check_num)
|
|
|
|
if perf_result.get("found") and perf_result.get("data"):
|
|
perf_data = perf_result["data"]
|
|
# Create CarPerformanceCheck record
|
|
perf_check = CarPerformanceCheck(
|
|
car_id=car.id,
|
|
check_number=perf_data.get("check_number") or check_num,
|
|
check_date=perf_data.get("check_date"),
|
|
valid_until=perf_data.get("valid_until"),
|
|
first_registration=perf_data.get("first_registration"),
|
|
mileage=perf_data.get("mileage"),
|
|
mileage_status=perf_data.get("mileage_status"),
|
|
seize_count=perf_data.get("seize_count", 0),
|
|
collateral_count=perf_data.get("collateral_count", 0),
|
|
is_flood_damaged=perf_data.get("is_flood_damaged", False),
|
|
is_fire_damaged=perf_data.get("is_fire_damaged", False),
|
|
is_total_loss=perf_data.get("is_total_loss", False),
|
|
engine_status=perf_data.get("engine_status"),
|
|
transmission_status=perf_data.get("transmission_status"),
|
|
power_delivery_status=perf_data.get("power_delivery_status"),
|
|
raw_data=perf_data,
|
|
raw_html=perf_result.get("raw_html", "")[:50000],
|
|
)
|
|
db.add(perf_check)
|
|
db.flush()
|
|
|
|
# Capture PDF
|
|
try:
|
|
pdf_path = await capture_performance_check_pdf(perf_check.check_number, car.id)
|
|
if pdf_path:
|
|
perf_check.pdf_path = pdf_path
|
|
except Exception as pdf_error:
|
|
logger.warning(f"PDF capture failed: {pdf_error}")
|
|
|
|
db.commit()
|
|
db.refresh(perf_check)
|
|
except Exception as e:
|
|
logger.error(f"Failed to fetch performance check: {e}")
|
|
|
|
if not perf_check:
|
|
raise HTTPException(status_code=404, detail="Performance check not available for this car")
|
|
|
|
# Check if already purchased
|
|
existing_view = db.query(PerformanceCheckView).filter(
|
|
PerformanceCheckView.user_id == current_user.id,
|
|
PerformanceCheckView.car_id == car_id
|
|
).first()
|
|
|
|
if existing_view:
|
|
return {"message": "Already purchased", "cc_balance": current_user.cc_balance}
|
|
|
|
# Check if user has enough CC
|
|
if (current_user.cc_balance or 0) < PERFORMANCE_CHECK_COST:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail=f"Insufficient CC balance. You need {PERFORMANCE_CHECK_COST} CC to view performance check."
|
|
)
|
|
|
|
# Deduct CC and create view record
|
|
current_user.cc_balance = (current_user.cc_balance or 0) - PERFORMANCE_CHECK_COST
|
|
|
|
perf_view = PerformanceCheckView(
|
|
user_id=current_user.id,
|
|
car_id=car_id,
|
|
cc_paid=PERFORMANCE_CHECK_COST
|
|
)
|
|
db.add(perf_view)
|
|
db.commit()
|
|
|
|
return {
|
|
"message": "Purchase successful",
|
|
"cc_balance": current_user.cc_balance,
|
|
"car_id": car_id
|
|
}
|
|
|
|
|
|
@router.get("/check-performance-check/{car_id}")
|
|
def check_performance_check_view(
|
|
car_id: int,
|
|
current_user: User = Depends(get_current_user),
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""Check if user has purchased performance check view for a specific car"""
|
|
# Check if performance check exists for this car
|
|
perf_check = db.query(CarPerformanceCheck).filter(
|
|
CarPerformanceCheck.car_id == car_id
|
|
).first()
|
|
|
|
# Check 1: Purchased performance check (0.1 CC)
|
|
existing_perf_view = db.query(PerformanceCheckView).filter(
|
|
PerformanceCheckView.user_id == current_user.id,
|
|
PerformanceCheckView.car_id == car_id
|
|
).first()
|
|
|
|
# Check 2: Purchased full car view (1 CC) -> performance check included free
|
|
existing_car_view = db.query(CarView).filter(
|
|
CarView.user_id == current_user.id,
|
|
CarView.car_id == car_id
|
|
).first()
|
|
|
|
has_access = (existing_perf_view is not None) or (existing_car_view is not None)
|
|
|
|
return {
|
|
"has_access": has_access,
|
|
"has_performance_check": perf_check is not None,
|
|
"cc_balance": current_user.cc_balance or 0,
|
|
"cost": PERFORMANCE_CHECK_COST,
|
|
"included_in_car_view": existing_car_view is not None # True if already purchased car view
|
|
}
|
|
|
|
|
|
@router.get("/payment-info")
|
|
def get_payment_info():
|
|
"""Get payment information including USDC wallet address"""
|
|
return {
|
|
"usdc_wallet_address": PaymentSettings.USDC_WALLET_ADDRESS,
|
|
"usdc_network": PaymentSettings.USDC_NETWORK,
|
|
"min_charge_usd": PaymentSettings.MIN_CHARGE_USD,
|
|
"max_charge_usd": PaymentSettings.MAX_CHARGE_USD,
|
|
"supported_currencies": PaymentSettings.SUPPORTED_CURRENCIES,
|
|
"supported_methods": PaymentSettings.SUPPORTED_METHODS,
|
|
"rate": "1 USD = 1 CC",
|
|
}
|
|
|
|
|
|
@router.post("/charge")
|
|
def charge_cc(
|
|
request: ChargeRequest,
|
|
current_user: User = Depends(get_current_user),
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""Create a charge request (for card or bank transfer - requires admin verification)"""
|
|
# Validate amount
|
|
if request.amount < PaymentSettings.MIN_CHARGE_USD:
|
|
raise HTTPException(status_code=400, detail=f"Minimum charge amount is ${PaymentSettings.MIN_CHARGE_USD}")
|
|
|
|
if request.amount > PaymentSettings.MAX_CHARGE_USD:
|
|
raise HTTPException(status_code=400, detail=f"Maximum charge amount is ${PaymentSettings.MAX_CHARGE_USD}")
|
|
|
|
# Calculate CC amount (1 USD = 1 CC)
|
|
cc_amount = request.amount
|
|
|
|
# Determine status based on payment method
|
|
# Card payments would go through a payment gateway (not implemented yet)
|
|
# USDC and bank transfers require manual verification
|
|
status = "pending" if request.payment_method in ["usdc", "bank_transfer"] else "pending"
|
|
|
|
# Create charge history record
|
|
charge_record = ChargeHistory(
|
|
user_id=current_user.id,
|
|
amount=request.amount,
|
|
amount_usd=request.amount, # Backwards compatibility
|
|
cc_amount=cc_amount,
|
|
currency=request.currency,
|
|
payment_method=request.payment_method,
|
|
transaction_id=request.transaction_id,
|
|
wallet_address=request.wallet_address,
|
|
status=status
|
|
)
|
|
db.add(charge_record)
|
|
db.commit()
|
|
db.refresh(charge_record)
|
|
|
|
return {
|
|
"message": "Charge request created" if status == "pending" else "Charge successful",
|
|
"charge_id": charge_record.id,
|
|
"amount": request.amount,
|
|
"currency": request.currency,
|
|
"cc_amount": cc_amount,
|
|
"status": status,
|
|
"payment_info": {
|
|
"usdc_wallet": PaymentSettings.USDC_WALLET_ADDRESS if request.payment_method == "usdc" else None,
|
|
"network": PaymentSettings.USDC_NETWORK if request.payment_method == "usdc" else None,
|
|
}
|
|
}
|
|
|
|
|
|
@router.post("/charge/usdc")
|
|
def charge_cc_usdc(
|
|
request: USDCChargeRequest,
|
|
current_user: User = Depends(get_current_user),
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""Create USDC charge request with transaction hash"""
|
|
# Validate amount
|
|
if request.amount_usdc < PaymentSettings.MIN_CHARGE_USD:
|
|
raise HTTPException(status_code=400, detail=f"Minimum charge amount is {PaymentSettings.MIN_CHARGE_USD} USDC")
|
|
|
|
if request.amount_usdc > PaymentSettings.MAX_CHARGE_USD:
|
|
raise HTTPException(status_code=400, detail=f"Maximum charge amount is {PaymentSettings.MAX_CHARGE_USD} USDC")
|
|
|
|
# Check for duplicate transaction
|
|
existing = db.query(ChargeHistory).filter(
|
|
ChargeHistory.transaction_id == request.transaction_hash
|
|
).first()
|
|
if existing:
|
|
raise HTTPException(status_code=400, detail="This transaction has already been submitted")
|
|
|
|
# Create pending charge record
|
|
charge_record = ChargeHistory(
|
|
user_id=current_user.id,
|
|
amount=request.amount_usdc,
|
|
amount_usd=request.amount_usdc,
|
|
cc_amount=request.amount_usdc,
|
|
currency="USDC",
|
|
payment_method="usdc",
|
|
transaction_id=request.transaction_hash,
|
|
wallet_address=request.wallet_address,
|
|
status="pending"
|
|
)
|
|
db.add(charge_record)
|
|
db.commit()
|
|
db.refresh(charge_record)
|
|
|
|
return {
|
|
"message": "USDC payment submitted for verification",
|
|
"charge_id": charge_record.id,
|
|
"amount_usdc": request.amount_usdc,
|
|
"cc_amount": request.amount_usdc,
|
|
"status": "pending",
|
|
"transaction_hash": request.transaction_hash
|
|
}
|
|
|
|
|
|
@router.get("/charge-history")
|
|
def get_charge_history(
|
|
current_user: User = Depends(get_current_user),
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""Get user's charge history"""
|
|
history = db.query(ChargeHistory).filter(
|
|
ChargeHistory.user_id == current_user.id
|
|
).order_by(desc(ChargeHistory.created_at)).limit(50).all()
|
|
|
|
return [
|
|
{
|
|
"id": h.id,
|
|
"amount": h.amount or h.amount_usd,
|
|
"amount_usd": h.amount_usd,
|
|
"currency": h.currency or "USD",
|
|
"cc_amount": h.cc_amount,
|
|
"payment_method": h.payment_method,
|
|
"transaction_id": h.transaction_id,
|
|
"status": h.status,
|
|
"created_at": h.created_at.isoformat() if h.created_at else None
|
|
}
|
|
for h in history
|
|
]
|
|
|
|
|
|
# Admin endpoints for payment verification
|
|
@router.get("/admin/pending")
|
|
def admin_get_pending_payments(
|
|
db: Session = Depends(get_db),
|
|
current_user: User = Depends(get_current_admin_user)
|
|
):
|
|
"""Get all pending payment requests (Admin only)"""
|
|
pending = db.query(ChargeHistory).filter(
|
|
ChargeHistory.status == "pending"
|
|
).order_by(desc(ChargeHistory.created_at)).all()
|
|
|
|
return [
|
|
{
|
|
"id": h.id,
|
|
"user_id": h.user_id,
|
|
"user_email": h.user.email if h.user else None,
|
|
"user_name": h.user.name if h.user else None,
|
|
"amount": h.amount or h.amount_usd,
|
|
"currency": h.currency or "USD",
|
|
"cc_amount": h.cc_amount,
|
|
"payment_method": h.payment_method,
|
|
"transaction_id": h.transaction_id,
|
|
"wallet_address": h.wallet_address,
|
|
"status": h.status,
|
|
"created_at": h.created_at.isoformat() if h.created_at else None
|
|
}
|
|
for h in pending
|
|
]
|
|
|
|
|
|
@router.get("/admin/all")
|
|
def admin_get_all_payments(
|
|
status: str = None,
|
|
page: int = 1,
|
|
page_size: int = 20,
|
|
db: Session = Depends(get_db),
|
|
current_user: User = Depends(get_current_admin_user)
|
|
):
|
|
"""Get all payment records with optional status filter (Admin only)"""
|
|
query = db.query(ChargeHistory)
|
|
|
|
if status:
|
|
query = query.filter(ChargeHistory.status == status)
|
|
|
|
total = query.count()
|
|
payments = query.order_by(desc(ChargeHistory.created_at)).offset((page - 1) * page_size).limit(page_size).all()
|
|
|
|
return {
|
|
"payments": [
|
|
{
|
|
"id": h.id,
|
|
"user_id": h.user_id,
|
|
"user_email": h.user.email if h.user else None,
|
|
"user_name": h.user.name if h.user else None,
|
|
"amount": h.amount or h.amount_usd,
|
|
"currency": h.currency or "USD",
|
|
"cc_amount": h.cc_amount,
|
|
"payment_method": h.payment_method,
|
|
"transaction_id": h.transaction_id,
|
|
"wallet_address": h.wallet_address,
|
|
"admin_note": h.admin_note,
|
|
"status": h.status,
|
|
"verified_at": h.verified_at.isoformat() if h.verified_at else None,
|
|
"created_at": h.created_at.isoformat() if h.created_at else None
|
|
}
|
|
for h in payments
|
|
],
|
|
"total": total,
|
|
"page": page,
|
|
"page_size": page_size
|
|
}
|
|
|
|
|
|
@router.put("/admin/{charge_id}/verify")
|
|
def admin_verify_payment(
|
|
charge_id: int,
|
|
approved: bool,
|
|
admin_note: str = None,
|
|
db: Session = Depends(get_db),
|
|
current_user: User = Depends(get_current_admin_user)
|
|
):
|
|
"""Verify and approve/reject a pending payment (Admin only)"""
|
|
charge = db.query(ChargeHistory).filter(ChargeHistory.id == charge_id).first()
|
|
if not charge:
|
|
raise HTTPException(status_code=404, detail="Charge record not found")
|
|
|
|
if charge.status != "pending":
|
|
raise HTTPException(status_code=400, detail=f"Charge is already {charge.status}")
|
|
|
|
if approved:
|
|
charge.status = "completed"
|
|
charge.verified_at = datetime.utcnow()
|
|
charge.verified_by = current_user.id
|
|
charge.admin_note = admin_note
|
|
|
|
# Credit CC to user
|
|
user = db.query(User).filter(User.id == charge.user_id).first()
|
|
if user:
|
|
user.cc_balance = (user.cc_balance or 0) + charge.cc_amount
|
|
|
|
# Trigger referral reward if applicable
|
|
if user.referred_by:
|
|
referrer = db.query(User).filter(
|
|
User.referral_code == user.referred_by
|
|
).first()
|
|
if referrer:
|
|
create_referral_reward(
|
|
referrer_id=referrer.id,
|
|
referred_user_id=user.id,
|
|
payment_amount=charge.amount_usd or charge.amount,
|
|
db=db
|
|
)
|
|
|
|
# Send notification to user
|
|
notify_system(
|
|
db,
|
|
user.id,
|
|
"Payment Confirmed",
|
|
f"Your payment of {charge.amount} {charge.currency or 'USD'} has been confirmed. {charge.cc_amount} CC has been added to your balance.",
|
|
"/profile"
|
|
)
|
|
else:
|
|
charge.status = "rejected"
|
|
charge.verified_at = datetime.utcnow()
|
|
charge.verified_by = current_user.id
|
|
charge.admin_note = admin_note
|
|
|
|
# Send notification to user
|
|
user = db.query(User).filter(User.id == charge.user_id).first()
|
|
if user:
|
|
notify_system(
|
|
db,
|
|
user.id,
|
|
"Payment Rejected",
|
|
f"Your payment request for {charge.amount} {charge.currency or 'USD'} was rejected. Reason: {admin_note or 'No reason provided'}",
|
|
"/profile"
|
|
)
|
|
|
|
db.commit()
|
|
|
|
return {
|
|
"message": f"Payment {'approved' if approved else 'rejected'}",
|
|
"charge_id": charge_id,
|
|
"new_status": charge.status
|
|
}
|
|
|
|
|
|
# ============================================
|
|
# Stripe Payment Endpoints
|
|
# ============================================
|
|
|
|
class CreateCheckoutRequest(BaseModel):
|
|
package_id: int
|
|
|
|
|
|
@router.get("/stripe-key")
|
|
def get_stripe_publishable_key():
|
|
"""Get Stripe publishable key for frontend"""
|
|
return {"publishable_key": settings.STRIPE_PUBLISHABLE_KEY}
|
|
|
|
|
|
@router.get("/packages")
|
|
def get_cc_packages(db: Session = Depends(get_db)):
|
|
"""Get available CC packages"""
|
|
# Get system settings for cars_per_cc
|
|
system_settings = db.query(SystemSettings).first()
|
|
cars_per_cc = system_settings.cars_per_cc if system_settings and system_settings.cars_per_cc else 3
|
|
|
|
# First try to get from database
|
|
packages = db.query(CCPackage).filter(CCPackage.is_active == True).order_by(CCPackage.sort_order).all()
|
|
|
|
# If no packages in DB, initialize with defaults
|
|
if not packages:
|
|
for pkg_data in DEFAULT_CC_PACKAGES:
|
|
pkg = CCPackage(**pkg_data)
|
|
db.add(pkg)
|
|
db.commit()
|
|
packages = db.query(CCPackage).filter(CCPackage.is_active == True).order_by(CCPackage.sort_order).all()
|
|
|
|
return [
|
|
{
|
|
"id": pkg.id,
|
|
"name": pkg.name,
|
|
"price_usd": pkg.price_usd,
|
|
"cc_amount": pkg.cc_amount,
|
|
"bonus_cc": pkg.bonus_cc,
|
|
"total_cc": pkg.cc_amount + pkg.bonus_cc,
|
|
"discount_percent": pkg.discount_percent,
|
|
"recommendations": (pkg.cc_amount + pkg.bonus_cc) * cars_per_cc,
|
|
"cars_per_cc": cars_per_cc, # 프론트엔드에서 표시용
|
|
}
|
|
for pkg in packages
|
|
]
|
|
|
|
|
|
@router.post("/create-checkout-session")
|
|
def create_checkout_session(
|
|
request: CreateCheckoutRequest,
|
|
current_user: User = Depends(get_current_user),
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""Create Stripe checkout session for CC purchase"""
|
|
if not settings.STRIPE_SECRET_KEY:
|
|
raise HTTPException(status_code=500, detail="Stripe is not configured")
|
|
|
|
# Get package
|
|
package = db.query(CCPackage).filter(CCPackage.id == request.package_id).first()
|
|
if not package:
|
|
raise HTTPException(status_code=404, detail="Package not found")
|
|
|
|
if not package.is_active:
|
|
raise HTTPException(status_code=400, detail="This package is no longer available")
|
|
|
|
try:
|
|
# Create Stripe Checkout Session
|
|
checkout_session = stripe.checkout.Session.create(
|
|
payment_method_types=["card"],
|
|
line_items=[
|
|
{
|
|
"price_data": {
|
|
"currency": "usd",
|
|
"unit_amount": package.price_usd * 100, # Stripe uses cents
|
|
"product_data": {
|
|
"name": f"AutonetSellCar CC - {package.name}",
|
|
"description": f"{package.cc_amount + package.bonus_cc} CC ({package.cc_amount} + {package.bonus_cc} bonus)",
|
|
},
|
|
},
|
|
"quantity": 1,
|
|
}
|
|
],
|
|
mode="payment",
|
|
success_url=f"{settings.STRIPE_SUCCESS_URL}?session_id={{CHECKOUT_SESSION_ID}}",
|
|
cancel_url=settings.STRIPE_CANCEL_URL,
|
|
client_reference_id=str(current_user.id),
|
|
metadata={
|
|
"user_id": str(current_user.id),
|
|
"package_id": str(package.id),
|
|
"cc_amount": str(package.cc_amount),
|
|
"bonus_cc": str(package.bonus_cc),
|
|
},
|
|
customer_email=current_user.email,
|
|
)
|
|
|
|
# Create pending charge record
|
|
charge_record = ChargeHistory(
|
|
user_id=current_user.id,
|
|
package_id=package.id,
|
|
amount=package.price_usd,
|
|
amount_usd=package.price_usd,
|
|
cc_amount=package.cc_amount,
|
|
bonus_cc=package.bonus_cc,
|
|
currency="USD",
|
|
payment_method="stripe",
|
|
stripe_session_id=checkout_session.id,
|
|
status="pending"
|
|
)
|
|
db.add(charge_record)
|
|
db.commit()
|
|
|
|
return {
|
|
"checkout_url": checkout_session.url,
|
|
"session_id": checkout_session.id
|
|
}
|
|
|
|
except stripe.error.StripeError as e:
|
|
logger.error(f"Stripe error: {e}")
|
|
raise HTTPException(status_code=400, detail=str(e))
|
|
|
|
|
|
@router.post("/webhook")
|
|
async def stripe_webhook(
|
|
request: Request,
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""Handle Stripe webhook events"""
|
|
payload = await request.body()
|
|
sig_header = request.headers.get("stripe-signature")
|
|
|
|
if not settings.STRIPE_WEBHOOK_SECRET:
|
|
logger.warning("Stripe webhook secret not configured")
|
|
raise HTTPException(status_code=500, detail="Webhook not configured")
|
|
|
|
try:
|
|
event = stripe.Webhook.construct_event(
|
|
payload, sig_header, settings.STRIPE_WEBHOOK_SECRET
|
|
)
|
|
except ValueError as e:
|
|
logger.error(f"Invalid payload: {e}")
|
|
raise HTTPException(status_code=400, detail="Invalid payload")
|
|
except stripe.error.SignatureVerificationError as e:
|
|
logger.error(f"Invalid signature: {e}")
|
|
raise HTTPException(status_code=400, detail="Invalid signature")
|
|
|
|
# Handle the checkout.session.completed event
|
|
if event["type"] == "checkout.session.completed":
|
|
session = event["data"]["object"]
|
|
|
|
# Get charge record by session ID
|
|
charge = db.query(ChargeHistory).filter(
|
|
ChargeHistory.stripe_session_id == session["id"]
|
|
).first()
|
|
|
|
if charge and charge.status == "pending":
|
|
# Update charge record
|
|
charge.status = "completed"
|
|
charge.stripe_payment_intent_id = session.get("payment_intent")
|
|
charge.verified_at = datetime.utcnow()
|
|
|
|
# Credit CC to user
|
|
user = db.query(User).filter(User.id == charge.user_id).first()
|
|
if user:
|
|
total_cc = charge.cc_amount + (charge.bonus_cc or 0)
|
|
user.cc_balance = (user.cc_balance or 0) + total_cc
|
|
|
|
# Trigger referral reward if applicable
|
|
if user.referred_by:
|
|
referrer = db.query(User).filter(
|
|
User.referral_code == user.referred_by
|
|
).first()
|
|
if referrer:
|
|
create_referral_reward(
|
|
referrer_id=referrer.id,
|
|
referred_user_id=user.id,
|
|
payment_amount=charge.amount_usd or charge.amount,
|
|
db=db
|
|
)
|
|
|
|
# Send notification
|
|
notify_system(
|
|
db,
|
|
user.id,
|
|
"CC Purchase Successful",
|
|
f"Your purchase of {total_cc} CC has been completed. Your new balance is {user.cc_balance} CC.",
|
|
"/cc"
|
|
)
|
|
|
|
logger.info(f"CC credited: user={user.id}, amount={total_cc}")
|
|
|
|
db.commit()
|
|
|
|
elif event["type"] == "checkout.session.expired":
|
|
session = event["data"]["object"]
|
|
|
|
# Update charge record to cancelled
|
|
charge = db.query(ChargeHistory).filter(
|
|
ChargeHistory.stripe_session_id == session["id"]
|
|
).first()
|
|
|
|
if charge and charge.status == "pending":
|
|
charge.status = "cancelled"
|
|
db.commit()
|
|
|
|
return {"status": "success"}
|
|
|
|
|
|
@router.get("/checkout-success")
|
|
def checkout_success(
|
|
session_id: str,
|
|
current_user: User = Depends(get_current_user),
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""Verify checkout session and return result"""
|
|
# Find charge record
|
|
charge = db.query(ChargeHistory).filter(
|
|
ChargeHistory.stripe_session_id == session_id,
|
|
ChargeHistory.user_id == current_user.id
|
|
).first()
|
|
|
|
if not charge:
|
|
raise HTTPException(status_code=404, detail="Payment record not found")
|
|
|
|
# If still pending, try to verify with Stripe
|
|
if charge.status == "pending":
|
|
try:
|
|
session = stripe.checkout.Session.retrieve(session_id)
|
|
if session.payment_status == "paid":
|
|
charge.status = "completed"
|
|
charge.stripe_payment_intent_id = session.payment_intent
|
|
charge.verified_at = datetime.utcnow()
|
|
|
|
# Credit CC
|
|
total_cc = charge.cc_amount + (charge.bonus_cc or 0)
|
|
current_user.cc_balance = (current_user.cc_balance or 0) + total_cc
|
|
|
|
db.commit()
|
|
except stripe.error.StripeError as e:
|
|
logger.error(f"Error verifying session: {e}")
|
|
|
|
return {
|
|
"status": charge.status,
|
|
"cc_amount": charge.cc_amount,
|
|
"bonus_cc": charge.bonus_cc or 0,
|
|
"total_cc": charge.cc_amount + (charge.bonus_cc or 0),
|
|
"cc_balance": current_user.cc_balance or 0
|
|
}
|
|
|
|
|
|
# Manual CC charge request (for Russian users via Mongolian partner)
|
|
class ManualChargeRequest(BaseModel):
|
|
package_id: int
|
|
payment_note: Optional[str] = None # e.g., "Paid via Mongolian partner bank"
|
|
|
|
|
|
@router.post("/manual-request")
|
|
def create_manual_charge_request(
|
|
request: ManualChargeRequest,
|
|
current_user: User = Depends(get_current_user),
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""Create manual CC charge request (for Russian users)"""
|
|
# Get package
|
|
package = db.query(CCPackage).filter(CCPackage.id == request.package_id).first()
|
|
if not package:
|
|
raise HTTPException(status_code=404, detail="Package not found")
|
|
|
|
# Create pending charge record
|
|
charge_record = ChargeHistory(
|
|
user_id=current_user.id,
|
|
package_id=package.id,
|
|
amount=package.price_usd,
|
|
amount_usd=package.price_usd,
|
|
cc_amount=package.cc_amount,
|
|
bonus_cc=package.bonus_cc,
|
|
currency="USD",
|
|
payment_method="manual",
|
|
admin_note=request.payment_note,
|
|
status="pending"
|
|
)
|
|
db.add(charge_record)
|
|
db.commit()
|
|
db.refresh(charge_record)
|
|
|
|
# Notify admins
|
|
admins = db.query(User).filter(User.is_admin == True).all()
|
|
for admin in admins:
|
|
notify_system(
|
|
db,
|
|
admin.id,
|
|
"New Manual CC Request",
|
|
f"User {current_user.email} requested {package.cc_amount} CC (${package.price_usd}). Payment method: manual.",
|
|
"/admin/cc"
|
|
)
|
|
|
|
return {
|
|
"message": "Manual charge request created. An admin will verify your payment.",
|
|
"charge_id": charge_record.id,
|
|
"package": {
|
|
"name": package.name,
|
|
"price_usd": package.price_usd,
|
|
"cc_amount": package.cc_amount + package.bonus_cc
|
|
},
|
|
"status": "pending"
|
|
}
|