chore: import WonderQ project

WonderQ-Admin/app/routers/public.py

@@ -0,0 +1,129 @@
+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}