bac68842ef
Implement Wechat Mini Program phone number login flow for end customers: - add PhoneLoginIn Pydantic request schema - create wechat.py module for Wechat API interactions and phone code exchange - add customer JWT utilities and require_customer authentication dependency - add new public API endpoints: /api/public/auth/phone-login and /api/public/auth/me - add required environment config variables and update example .env - add comprehensive test cases for the new auth flow and endpoints
130 lines
4.6 KiB
Python
130 lines
4.6 KiB
Python
from fastapi import APIRouter, Depends, HTTPException, Query, status
|
|
from sqlalchemy import or_, select
|
|
from sqlalchemy.orm import Session, selectinload
|
|
from .shared import site_config
|
|
from ..auth import create_customer_token, require_customer
|
|
from ..database import get_db
|
|
from ..models import Customer, Destination, DestinationAlias, Lead, Product
|
|
from ..schemas import LeadCreateIn, PhoneLoginIn, ProductQuery, ProductStatus
|
|
from ..serializers import destination_dict, public_product_dict
|
|
from ..wechat import WechatApiError, WechatConfigError, exchange_phone_code
|
|
|
|
|
|
router = APIRouter()
|
|
|
|
|
|
def mask_phone(phone: str) -> str:
|
|
normalized = phone.strip()
|
|
if len(normalized) <= 7:
|
|
return "***"
|
|
return f"{normalized[:3]}****{normalized[-4:]}"
|
|
|
|
|
|
def public_customer_dict(customer: Customer) -> dict:
|
|
return {"id": customer.id, "phoneMasked": mask_phone(customer.phone)}
|
|
|
|
|
|
@router.get("/health")
|
|
def health():
|
|
return {"ok": True, "service": "miniapp-api"}
|
|
|
|
|
|
@router.get("/api/public/site-config")
|
|
def get_site_config(db: Session = Depends(get_db)):
|
|
return site_config(db, active_only=True)
|
|
|
|
|
|
@router.get("/api/public/products")
|
|
def list_products(
|
|
keyword: str | None = None,
|
|
destinationId: str | None = None,
|
|
status_value: ProductStatus = Query(default="published", alias="status"),
|
|
take: int = Query(default=48, ge=1, le=100),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
query = ProductQuery(keyword=keyword, destinationId=destinationId, status=status_value, take=take)
|
|
stmt = (
|
|
select(Product)
|
|
.options(selectinload(Product.destination).selectinload(Destination.aliases), selectinload(Product.images))
|
|
.where(Product.status == query.status)
|
|
.order_by(Product.sortWeight.asc(), Product.createdAt.asc())
|
|
.limit(query.take)
|
|
)
|
|
if query.destinationId:
|
|
stmt = stmt.where(Product.destinationId == query.destinationId)
|
|
if query.keyword:
|
|
pattern = f"%{query.keyword}%"
|
|
stmt = (
|
|
stmt.outerjoin(Product.destination)
|
|
.outerjoin(Destination.aliases)
|
|
.where(
|
|
or_(
|
|
Product.title.ilike(pattern),
|
|
Product.subtitle.ilike(pattern),
|
|
Product.tags.any(query.keyword),
|
|
Destination.name.ilike(pattern),
|
|
DestinationAlias.alias.ilike(pattern),
|
|
)
|
|
)
|
|
.distinct()
|
|
)
|
|
products = db.scalars(stmt).unique().all()
|
|
return {"items": [public_product_dict(product) for product in products]}
|
|
|
|
|
|
@router.get("/api/public/products/{product_id}")
|
|
def get_product(product_id: str, db: Session = Depends(get_db)):
|
|
stmt = select(Product).options(selectinload(Product.destination), selectinload(Product.images))
|
|
if product_id.isdigit():
|
|
stmt = stmt.where(Product.sourceId == int(product_id))
|
|
else:
|
|
stmt = stmt.where(Product.id == product_id)
|
|
product = db.scalars(stmt).first()
|
|
if not product:
|
|
raise HTTPException(status_code=404, detail="线路不存在")
|
|
return public_product_dict(product)
|
|
|
|
|
|
@router.get("/api/public/destinations")
|
|
def list_destinations(db: Session = Depends(get_db)):
|
|
destinations = db.scalars(
|
|
select(Destination)
|
|
.options(selectinload(Destination.aliases))
|
|
.where(Destination.isActive.is_(True))
|
|
.order_by(Destination.sortOrder.asc())
|
|
).all()
|
|
return {"items": [destination_dict(destination) for destination in destinations]}
|
|
|
|
|
|
@router.post("/api/public/auth/phone-login")
|
|
def phone_login(body: PhoneLoginIn, db: Session = Depends(get_db)):
|
|
try:
|
|
phone = exchange_phone_code(body.code)
|
|
except WechatConfigError as exc:
|
|
raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail=str(exc)) from exc
|
|
except WechatApiError as exc:
|
|
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc)) from exc
|
|
|
|
customer = db.scalar(select(Customer).where(Customer.phone == phone))
|
|
if not customer:
|
|
customer = Customer(phone=phone)
|
|
db.add(customer)
|
|
db.flush()
|
|
db.commit()
|
|
db.refresh(customer)
|
|
return {"token": create_customer_token(customer), "customer": public_customer_dict(customer)}
|
|
|
|
|
|
@router.get("/api/public/auth/me")
|
|
def current_customer(customer: Customer = Depends(require_customer)):
|
|
return public_customer_dict(customer)
|
|
|
|
|
|
@router.post("/api/public/leads", status_code=status.HTTP_201_CREATED)
|
|
def create_lead(body: LeadCreateIn, db: Session = Depends(get_db)):
|
|
lead = Lead(**body.model_dump(exclude_none=True), status="new")
|
|
db.add(lead)
|
|
db.commit()
|
|
db.refresh(lead)
|
|
return {"id": lead.id, "status": lead.status}
|