347 lines
12 KiB
Python
347 lines
12 KiB
Python
import hashlib
|
|
import hmac
|
|
import json
|
|
import os
|
|
import uuid
|
|
from datetime import datetime
|
|
from decimal import Decimal, InvalidOperation, ROUND_HALF_UP
|
|
from urllib.parse import parse_qs
|
|
|
|
from fastapi import APIRouter, Body, Depends, Header, HTTPException, Request
|
|
from sqlalchemy import func
|
|
from sqlalchemy.orm import Session
|
|
|
|
from database import get_db
|
|
from models import TokenAccount, TokenPaymentOrder, TokenPlan, TokenUsage, User
|
|
from responses import fail, ok
|
|
from services.huihui_payment import HuihuiPaymentClient, HuihuiPaymentError
|
|
from services.token_billing import DEFAULT_TOKEN_GRANT, get_or_create_account
|
|
|
|
router = APIRouter(tags=["Token"])
|
|
|
|
PAYMENT_METHODS = {"wechat": "WECHAT", "alipay": "ALIPAY"}
|
|
PAYMENT_SCENES = {"APP", "LITE", "JSAPI"}
|
|
SUCCESS_STATUSES = {"SUCCESS", "SUCCEEDED", "PAID", "COMPLETED", "TRADE_SUCCESS"}
|
|
FAILED_STATUSES = {"FAIL", "FAILED", "CLOSED", "CANCELLED", "CANCELED", "EXPIRED"}
|
|
|
|
|
|
def _require_user(authorization: str | None, db: Session) -> User:
|
|
if not authorization:
|
|
raise HTTPException(status_code=401, detail="未登录")
|
|
token = authorization.replace("Bearer ", "", 1).replace("bearer ", "", 1).strip()
|
|
user = db.query(User).filter(User.app_token == token).first()
|
|
if not user:
|
|
raise HTTPException(status_code=401, detail="会话无效或已过期")
|
|
return user
|
|
|
|
|
|
def _payment_client() -> HuihuiPaymentClient:
|
|
return HuihuiPaymentClient({
|
|
"HUIHUI_PAYMENT_BASE_URL": os.getenv(
|
|
"HUIHUI_PAYMENT_BASE_URL", "https://open.99hui.com/api/payment-v3"
|
|
),
|
|
"HUIHUI_APP_ID": os.getenv("HUIHUI_APP_ID", ""),
|
|
"HUIHUI_ACCESS_ID": os.getenv("HUIHUI_ACCESS_ID", ""),
|
|
"HUIHUI_ACCESS_SECRET": os.getenv("HUIHUI_ACCESS_SECRET", ""),
|
|
"HUIHUI_PAYMENT_TIMEOUT_SECONDS": os.getenv("HUIHUI_PAYMENT_TIMEOUT_SECONDS", "30"),
|
|
})
|
|
|
|
|
|
def _callback_url(order_no: str) -> str:
|
|
base = os.getenv(
|
|
"HUIHUI_PAYMENT_CALLBACK_BASE_URL", "https://digital.99hui.com"
|
|
).rstrip("/")
|
|
secret = os.getenv("HUIHUI_PAYMENT_CALLBACK_SECRET", "").strip()
|
|
if len(secret) < 16:
|
|
raise HuihuiPaymentError("会会支付回调密钥未配置")
|
|
signature = hmac.new(secret.encode(), order_no.encode(), hashlib.sha256).hexdigest()
|
|
return f"{base}/api/token/payment/callback/{order_no}/{signature}"
|
|
|
|
|
|
def _price_cents(price: float) -> int:
|
|
return int(
|
|
(Decimal(str(price)) * Decimal("100")).quantize(
|
|
Decimal("1"), rounding=ROUND_HALF_UP
|
|
)
|
|
)
|
|
|
|
|
|
def _payment_payload(order: TokenPaymentOrder, account: TokenAccount) -> dict:
|
|
return {**order.to_dict(), "balance": account.balance}
|
|
|
|
|
|
def _nested_payload(value):
|
|
if isinstance(value, str):
|
|
text = value.strip()
|
|
if text[:1] in ("{", "["):
|
|
try:
|
|
return _nested_payload(json.loads(text))
|
|
except (TypeError, ValueError):
|
|
return value
|
|
return value
|
|
if isinstance(value, list):
|
|
return [_nested_payload(item) for item in value]
|
|
if isinstance(value, dict):
|
|
return {key: _nested_payload(item) for key, item in value.items()}
|
|
return value
|
|
|
|
|
|
def _find_value(payload, *names):
|
|
expected = {name.lower() for name in names}
|
|
if isinstance(payload, dict):
|
|
for key, value in payload.items():
|
|
if key.lower() in expected and value not in (None, ""):
|
|
return value
|
|
for value in payload.values():
|
|
found = _find_value(value, *names)
|
|
if found not in (None, ""):
|
|
return found
|
|
elif isinstance(payload, list):
|
|
for value in payload:
|
|
found = _find_value(value, *names)
|
|
if found not in (None, ""):
|
|
return found
|
|
return None
|
|
|
|
|
|
def _callback_amount_cents(payload) -> int | None:
|
|
value = _find_value(
|
|
payload,
|
|
"actualAmt",
|
|
"payAmt",
|
|
"masterOrderAmt",
|
|
"orderAmt",
|
|
"amount",
|
|
"totalAmount",
|
|
)
|
|
if value in (None, ""):
|
|
return None
|
|
try:
|
|
return int(
|
|
(Decimal(str(value)) * Decimal("100")).quantize(
|
|
Decimal("1"), rounding=ROUND_HALF_UP
|
|
)
|
|
)
|
|
except (InvalidOperation, TypeError, ValueError):
|
|
return None
|
|
|
|
|
|
@router.get("/token/balance")
|
|
def balance(authorization: str = Header(None), db: Session = Depends(get_db)):
|
|
user = _require_user(authorization, db)
|
|
acc = get_or_create_account(db, user.id)
|
|
return ok({
|
|
"balance": acc.balance,
|
|
"totalGranted": acc.total_granted,
|
|
"totalConsumed": acc.total_consumed,
|
|
})
|
|
|
|
|
|
@router.get("/token/plans")
|
|
def plans(authorization: str = Header(None), db: Session = Depends(get_db)):
|
|
_require_user(authorization, db)
|
|
items = db.query(TokenPlan).order_by(TokenPlan.price.asc()).all()
|
|
return ok([p.to_dict() for p in items])
|
|
|
|
|
|
# 积分只会在会会支付回调确认成功后到账。
|
|
@router.post("/token/charge")
|
|
def charge(payload: dict = Body(...), authorization: str = Header(None), db: Session = Depends(get_db)):
|
|
user = _require_user(authorization, db)
|
|
plan = db.query(TokenPlan).filter(TokenPlan.id == payload.get("planId")).first()
|
|
if not plan:
|
|
return fail("套餐不存在", 404)
|
|
|
|
payment_method = str(payload.get("paymentMethod") or "").lower()
|
|
pay_type = PAYMENT_METHODS.get(payment_method)
|
|
if not pay_type:
|
|
return fail("请选择正确的支付方式", 400)
|
|
pay_way = str(payload.get("payScene") or "APP").upper()
|
|
if pay_way not in PAYMENT_SCENES:
|
|
return fail("当前支付场景不受支持", 400)
|
|
|
|
cents = _price_cents(plan.price)
|
|
order = TokenPaymentOrder(
|
|
order_no=f"AV{datetime.utcnow().strftime('%Y%m%d%H%M%S')}{uuid.uuid4().hex[:12].upper()}",
|
|
user_id=user.id,
|
|
plan_id=plan.id,
|
|
payment_method=payment_method,
|
|
pay_type=pay_type,
|
|
pay_way=pay_way,
|
|
points_amount=plan.amount,
|
|
price_cents=cents,
|
|
status="pending",
|
|
)
|
|
db.add(order)
|
|
db.commit()
|
|
|
|
try:
|
|
callback_url = _callback_url(order.order_no)
|
|
except HuihuiPaymentError as exc:
|
|
order.status = "failed"
|
|
order.failure_reason = str(exc)
|
|
db.commit()
|
|
return fail(str(exc), 503)
|
|
|
|
try:
|
|
result = _payment_client().create_payment(
|
|
huihui_token=user.huihui_token,
|
|
huihui_user_id=user.huihui_user_id,
|
|
real_name=user.nickname,
|
|
order_no=order.order_no,
|
|
amount=f"{cents / 100:.2f}",
|
|
points_amount=plan.amount,
|
|
pay_type=pay_type,
|
|
pay_way=pay_way,
|
|
callback_url=callback_url,
|
|
)
|
|
except HuihuiPaymentError as exc:
|
|
order.status = "failed"
|
|
order.failure_reason = str(exc)[:500]
|
|
db.commit()
|
|
return fail(str(exc), 502)
|
|
|
|
db.refresh(order)
|
|
if order.status != "paid":
|
|
order.provider_order_id = str(result.get("orderId") or "")
|
|
order.provider_order_no = str(result.get("orderNo") or "")
|
|
order.provider_status = str(result.get("status") or "pending")
|
|
message = result.get("payMessage") or ""
|
|
order.pay_message = (
|
|
json.dumps(message, ensure_ascii=False)
|
|
if isinstance(message, (dict, list))
|
|
else str(message)
|
|
)
|
|
if order.provider_status.upper() in FAILED_STATUSES:
|
|
order.status = "failed"
|
|
order.failure_reason = str(result.get("bankReturnMsg") or "支付下单失败")[:500]
|
|
db.commit()
|
|
|
|
return ok(_payment_payload(order, get_or_create_account(db, user.id)))
|
|
|
|
|
|
@router.get("/token/payment/{order_id}")
|
|
def payment_status(order_id: str, authorization: str = Header(None), db: Session = Depends(get_db)):
|
|
user = _require_user(authorization, db)
|
|
order = db.query(TokenPaymentOrder).filter(
|
|
TokenPaymentOrder.id == order_id,
|
|
TokenPaymentOrder.user_id == user.id,
|
|
).first()
|
|
if not order:
|
|
return fail("支付订单不存在", 404)
|
|
return ok(_payment_payload(order, get_or_create_account(db, user.id)))
|
|
|
|
|
|
@router.post("/token/payment/callback/{order_no}/{callback_signature}")
|
|
async def payment_callback(
|
|
order_no: str,
|
|
callback_signature: str,
|
|
request: Request,
|
|
db: Session = Depends(get_db),
|
|
):
|
|
secret = os.getenv("HUIHUI_PAYMENT_CALLBACK_SECRET", "").strip()
|
|
expected = hmac.new(secret.encode(), order_no.encode(), hashlib.sha256).hexdigest()
|
|
if len(secret) < 16 or not hmac.compare_digest(callback_signature, expected):
|
|
raise HTTPException(status_code=404, detail="Not found")
|
|
|
|
content_type = request.headers.get("content-type", "").lower()
|
|
if "application/json" in content_type:
|
|
try:
|
|
payload = await request.json()
|
|
except ValueError:
|
|
return fail("支付回调格式不正确", 400)
|
|
else:
|
|
raw = (await request.body()).decode("utf-8", errors="replace")
|
|
payload = {key: values[-1] for key, values in parse_qs(raw).items()}
|
|
payload = _nested_payload(payload)
|
|
|
|
payload_order_no = str(_find_value(
|
|
payload,
|
|
"masterOrderNo",
|
|
"master_order_no",
|
|
"orderNo",
|
|
"order_no",
|
|
"bizOrderNo",
|
|
) or "").strip()
|
|
if payload_order_no and payload_order_no != order_no:
|
|
return fail("支付回调订单号不匹配", 422)
|
|
|
|
order = db.query(TokenPaymentOrder).filter(TokenPaymentOrder.order_no == order_no).first()
|
|
if not order:
|
|
return fail("支付订单不存在", 404)
|
|
if order.status == "paid":
|
|
return ok({"received": True, "duplicate": True})
|
|
|
|
provider_status = str(_find_value(
|
|
payload, "status", "payStatus", "tradeStatus", "paymentStatus"
|
|
) or "").upper()
|
|
order.provider_status = provider_status
|
|
if provider_status not in SUCCESS_STATUSES:
|
|
if provider_status in FAILED_STATUSES:
|
|
order.status = "failed"
|
|
order.failure_reason = str(
|
|
_find_value(payload, "message", "errorMsg", "failReason") or "支付失败"
|
|
)[:500]
|
|
db.commit()
|
|
return ok({"received": True, "paid": False})
|
|
|
|
paid_cents = _callback_amount_cents(payload)
|
|
if paid_cents is None or paid_cents != order.price_cents:
|
|
order.failure_reason = "支付回调金额不匹配"
|
|
db.commit()
|
|
return fail("支付金额不匹配", 422)
|
|
|
|
updated = db.query(TokenPaymentOrder).filter(
|
|
TokenPaymentOrder.id == order.id,
|
|
TokenPaymentOrder.status != "paid",
|
|
).update({
|
|
TokenPaymentOrder.status: "paid",
|
|
TokenPaymentOrder.provider_status: provider_status,
|
|
TokenPaymentOrder.paid_at: datetime.utcnow(),
|
|
TokenPaymentOrder.failure_reason: "",
|
|
}, synchronize_session=False)
|
|
if updated:
|
|
account = db.query(TokenAccount).filter(TokenAccount.user_id == order.user_id).first()
|
|
if account is None:
|
|
account = TokenAccount(
|
|
user_id=order.user_id,
|
|
balance=DEFAULT_TOKEN_GRANT,
|
|
total_granted=DEFAULT_TOKEN_GRANT,
|
|
total_consumed=0,
|
|
)
|
|
db.add(account)
|
|
db.flush()
|
|
account.balance = int(account.balance or 0) + order.points_amount
|
|
account.total_granted = int(account.total_granted or 0) + order.points_amount
|
|
db.commit()
|
|
return ok({"received": True, "paid": True})
|
|
|
|
|
|
@router.get("/token/usage")
|
|
def usage(authorization: str = Header(None), db: Session = Depends(get_db)):
|
|
user = _require_user(authorization, db)
|
|
rows = (
|
|
db.query(
|
|
TokenUsage.avatar_id,
|
|
TokenUsage.source,
|
|
func.sum(TokenUsage.prompt_tokens),
|
|
func.sum(TokenUsage.completion_tokens),
|
|
func.sum(TokenUsage.total_tokens),
|
|
func.count(TokenUsage.id),
|
|
)
|
|
.filter(TokenUsage.user_id == user.id, TokenUsage.status == "completed")
|
|
.group_by(TokenUsage.avatar_id, TokenUsage.source)
|
|
.all()
|
|
)
|
|
return ok([
|
|
{
|
|
"avatarId": avatar_id,
|
|
"source": source,
|
|
"promptTokens": int(prompt_tokens or 0),
|
|
"completionTokens": int(completion_tokens or 0),
|
|
"totalTokens": int(total_tokens or 0),
|
|
"requestCount": int(request_count or 0),
|
|
}
|
|
for avatar_id, source, prompt_tokens, completion_tokens, total_tokens, request_count in rows
|
|
])
|