瀏覽代碼

refactor: add environment-aware configuration for payment providers and update error messages

jerry 1 月之前
父節點
當前提交
0846199123

+ 29 - 6
.env

@@ -1,15 +1,38 @@
+# ========================================================
+# 全局环境控制变量: 
+# - PROD : 生产正式环境 (使用 CREEM_PROD_*, STRIPE_PROD_*)
+# - DEV  : 开发测试环境 (使用 CREEM_TEST_*, STRIPE_TEST_*)
+# ========================================================
 ENV=DEV
+
 DATABASE_URL=mysql+asyncmy://root:GqLLL7Bofj0WaaOpp.0@text.skin:3306/book_user_info?charset=utf8mb4
 REDIS_URL=redis://:STEs2x6ML0U1HlpE9SojM6YU7QPhqzY8@text.skin:6379/0
 LLM_API_KEY=sk-7c48e820b0354188b0af4e5168c6d264
 LLM_BASE_URL=https://api.deepseek.com
 LLM_MODEL=deepseek-v4-flash
-STRIPE_API_KEY=sk_live_xxxx
-STRIPE_WEBHOOK_SECRET=whsec_xxxx
-CREEM_API_KEY=
-CREEM_WEBHOOK_SECRET=
-CREEM_BASE_URL=https://test-api.creem.io
-CREEM_PRODUCT_ID=
+
+# ---------------------------------------------
+# [支付配置 - 生产正式环境 PROD]
+# ---------------------------------------------
+CREEM_PROD_API_KEY=creem_5UDyaXyn6y3zKzstzv3AFr
+CREEM_PROD_WEBHOOK_SECRET=whsec_7NTsSWHgpzafRuO4WRfjmm
+CREEM_PROD_BASE_URL=https://api.creem.io
+CREEM_PROD_PRODUCT_ID=
+
+STRIPE_PROD_API_KEY=sk_live_xxxx
+STRIPE_PROD_WEBHOOK_SECRET=whsec_xxxx
+
+# ---------------------------------------------
+# [支付配置 - 测试沙盒环境 TEST / DEV]
+# ---------------------------------------------
+CREEM_TEST_API_KEY=creem_test_5zdG9ZU1U0unZcpgeYxDBB
+CREEM_TEST_WEBHOOK_SECRET=whsec_6jZ96XMeJZXCPzoO0Q4PoE
+CREEM_TEST_BASE_URL=https://test-api.creem.io
+CREEM_TEST_PRODUCT_ID=
+
+STRIPE_TEST_API_KEY=sk_test_xxxx
+STRIPE_TEST_WEBHOOK_SECRET=whsec_test_xxxx
+
 TELEGRAM_API_TOKEN=xxxxx
 WECHAT_API_TOKEN=a28233ef-80b6-4131-96c0-4cda1d06cefb
 WHATSAPP_API_BASE_URL=https://waha.text.skin

+ 146 - 1
app/api/endpoints/node_configuration.py

@@ -1,7 +1,9 @@
 import json
+import asyncio
 from datetime import datetime
 from typing import Optional, Dict, Any, List
-from fastapi import APIRouter, Depends, Query, Body
+from fastapi import APIRouter, Depends, Query, Body, Request
+from fastapi.responses import StreamingResponse
 from sqlalchemy.ext.asyncio import AsyncSession
 from redis.asyncio import Redis
 
@@ -137,6 +139,149 @@ async def delete_cluster_node(
     return success(data=result, message="Node deleted successfully")
 
 
+# ==================== Worker 节点实时日志流与历史查询接口 ====================
+@admin_required_router.get(
+    "/logs/stream",
+    summary="流式获取 Worker 节点实时日志 (SSE)",
+)
+async def stream_node_logs(
+    request: Request,
+    node_id: str = Query(..., description="节点 ID,如 node01"),
+    role: str = Query(..., description="角色: sentinel / booker / standalone"),
+    group_id: Optional[str] = Query(None, description="可选: 按 group_id 过滤"),
+    level: Optional[str] = Query(None, description="可选: 按日志级别过滤 (INFO/WARN/ERROR)"),
+    history_limit: int = Query(200, ge=0, le=1000, description="初始拉取的历史日志条目数"),
+    redis_client: Redis = Depends(get_redis_client),
+):
+    """
+    通过 Server-Sent Events (SSE) 流式返回 Worker 节点实时日志。
+    首先拉取 Redis Stream 最近的历史日志,随后持续挂起 xread 增量推送最新日志。
+    """
+    stream_key = f"vs:stream:logs:{node_id}:{role}"
+
+    async def log_generator():
+        last_id = "0-0"
+        # 1. 尝试拉取历史日志
+        if history_limit > 0:
+            try:
+                history_entries = await redis_client.xrevrange(stream_key, count=history_limit)
+                if history_entries:
+                    # 翻转为时间正序
+                    history_entries.reverse()
+                    for entry_id, fields in history_entries:
+                        last_id = entry_id
+                        msg_group = fields.get("group_id", "")
+                        msg_level = fields.get("level", "INFO")
+                        if group_id and msg_group and msg_group != group_id:
+                            continue
+                        if level and msg_level.upper() != level.upper():
+                            continue
+
+                        payload = {
+                            "id": entry_id,
+                            "timestamp": fields.get("timestamp", ""),
+                            "level": msg_level,
+                            "group_id": msg_group,
+                            "role": fields.get("role", role),
+                            "node_id": fields.get("node_id", node_id),
+                            "message": fields.get("message", ""),
+                        }
+                        yield f"id: {entry_id}\ndata: {json.dumps(payload, ensure_ascii=False)}\n\n"
+            except Exception as e:
+                yield f": error fetching history: {str(e)}\n\n"
+
+        # 如果没有历史记录,尝试定位到当前最新末尾
+        if last_id == "0-0":
+            try:
+                latest = await redis_client.xrevrange(stream_key, count=1)
+                if latest:
+                    last_id = latest[0][0]
+            except Exception:
+                pass
+
+        # 2. 循环监听增量实时流 (XREAD)
+        while not await request.is_disconnected():
+            try:
+                data = await redis_client.xread({stream_key: last_id}, count=50, block=1000)
+                if not data:
+                    # 发送注释心跳保持反向代理链路
+                    yield ": ping\n\n"
+                    continue
+
+                for s_key, entries in data:
+                    for entry_id, fields in entries:
+                        last_id = entry_id
+                        msg_group = fields.get("group_id", "")
+                        msg_level = fields.get("level", "INFO")
+                        if group_id and msg_group and msg_group != group_id:
+                            continue
+                        if level and msg_level.upper() != level.upper():
+                            continue
+
+                        payload = {
+                            "id": entry_id,
+                            "timestamp": fields.get("timestamp", ""),
+                            "level": msg_level,
+                            "group_id": msg_group,
+                            "role": fields.get("role", role),
+                            "node_id": fields.get("node_id", node_id),
+                            "message": fields.get("message", ""),
+                        }
+                        yield f"id: {entry_id}\ndata: {json.dumps(payload, ensure_ascii=False)}\n\n"
+
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                yield f": error: {str(e)}\n\n"
+                await asyncio.sleep(1)
+
+    return StreamingResponse(
+        log_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+        },
+    )
+
+
+@admin_required_router.get(
+    "/logs/history",
+    summary="查询 Worker 节点历史日志快照",
+    response_model=ApiResponse[List[Dict[str, Any]]],
+)
+async def get_node_logs_history(
+    node_id: str = Query(..., description="节点 ID"),
+    role: str = Query(..., description="角色: sentinel / booker / standalone"),
+    group_id: Optional[str] = Query(None, description="可选: 按 group_id 过滤"),
+    limit: int = Query(200, ge=1, le=1000, description="获取条数"),
+    redis_client: Redis = Depends(get_redis_client),
+):
+    stream_key = f"vs:stream:logs:{node_id}:{role}"
+    try:
+        entries = await redis_client.xrevrange(stream_key, count=limit)
+        results = []
+        if entries:
+            entries.reverse()
+            for entry_id, fields in entries:
+                msg_group = fields.get("group_id", "")
+                if group_id and msg_group and msg_group != group_id:
+                    continue
+                results.append({
+                    "id": entry_id,
+                    "timestamp": fields.get("timestamp", ""),
+                    "level": fields.get("level", "INFO"),
+                    "group_id": msg_group,
+                    "role": fields.get("role", role),
+                    "node_id": fields.get("node_id", node_id),
+                    "message": fields.get("message", ""),
+                })
+        return success(data=results)
+    except Exception as e:
+        return success(data=[])
+
+
 @admin_required_router.get(
     "/{entry_type}",
     summary="分页查询配置条目列表",

+ 11 - 0
app/api/endpoints/order.py

@@ -16,6 +16,7 @@ from app.schemas.order import (
     VasOrderOut,
     VasOrderPatchUserInputs,
     VasOrderUpdate,
+    VasOrderRegisterPayment,
 )
 from app.schemas.order_event import VasOrderEventCreate, VasOrderEventOut
 from app.services.order_event_service import OrderEventService
@@ -65,6 +66,16 @@ async def vas_order_create_by_admin(
     return success(data=created_order)
 
 
+@admin_required_router.post("/vas/order/register_payment", summary="管理员/客服登记实收金额与收款记录", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
+async def vas_order_register_payment(
+    payload: VasOrderRegisterPayment,
+    current_user: VasUser = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    order = await OrderService.register_payment(db, payload, current_user)
+    return success(data=order)
+
+
 @admin_required_router.post("/vas/order/mark_completed", summary="标记订单履约完成并开启退款风险期", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
 async def vas_order_mark_completed(
     order_id: str,

+ 7 - 3
app/api/endpoints/payment.py

@@ -1,6 +1,7 @@
-from typing import List
+from typing import List, Optional
 from fastapi import APIRouter, Query, Depends
 from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.biz_exception import BizLogicError
 from app.core.redis import get_redis_client
 from app.core.database import get_db
 from app.core.auth import get_current_user
@@ -153,8 +154,11 @@ async def vas_payment_qr_list_qrcode_by_provider(provider_id: int, db: AsyncSess
 
 
 @protected_router.get("/vas/payment_qr/qrcode", summary="获取支付的QRCode", tags=["textskin"], response_model=ApiResponse[VasPaymentQrOut])
-async def vas_payment_qr_get_qrcode_by_id(id: int, db: AsyncSession = Depends(get_db)):
-    qr = await PaymentQrService.get_by_id(db, id)
+async def vas_payment_qr_get_qrcode_by_id(
+    qr_id: int = Query(..., description="收款码唯一 ID (qr_id)"),
+    db: AsyncSession = Depends(get_db)
+):
+    qr = await PaymentQrService.get_by_id(db, qr_id)
     return success(data=qr)
 
 

+ 22 - 16
app/api/endpoints/webhook.py

@@ -13,7 +13,7 @@ from app.schemas.common import ApiResponse
 from app.schemas.webhook import SMSHelperWebhookPayload
 from app.services.webhook_service import WebhookService
 from app.models.payment_provider import VasPaymentProvider
-from app.core.creem import verify_creem_signature
+from app.core.creem import verify_creem_signature, CreemClient
 
 public_router = APIRouter()
 protected_router = APIRouter()
@@ -47,13 +47,13 @@ async def webhook_stripe(
     logger.info("Payload raw: %s", payload.decode("utf-8", errors="ignore"))
     logger.info(
         "Webhook secret prefix: %s",
-        settings.stripe_webhook_secret[:8] if settings.stripe_webhook_secret else None,
+        settings.active_stripe_webhook_secret[:8] if settings.active_stripe_webhook_secret else None,
     )
     
     event = stripe.Webhook.construct_event(
         payload=payload,
         sig_header=sig_header,
-        secret=settings.stripe_webhook_secret,
+        secret=settings.active_stripe_webhook_secret,
     )
     res = await WebhookService.stripe_payment_webhook(db, event)
     return success()
@@ -74,22 +74,28 @@ async def webhook_creem(
 
     logger.info("💳 [CREEM] Webhook received, signature=%s, bytes_len=%d", sig_header, len(payload))
 
-    # 获取 Provider 配置的 secret 或全局设置
+    # 获取 Provider 配置的 secret 或全局设置(支持生产与测试候选密钥)
     stmt = select(VasPaymentProvider).where(VasPaymentProvider.name == "creem")
     provider = (await db.execute(stmt)).scalar_one_or_none()
-    webhook_secret = ""
-    if provider and provider.config and isinstance(provider.config, dict):
-        webhook_secret = provider.config.get("webhook_secret", "")
-    if not webhook_secret:
-        webhook_secret = settings.creem_webhook_secret
+    provider_config = provider.config if (provider and isinstance(provider.config, dict)) else {}
+    
+    candidate_secrets = [
+        s for s in [
+            CreemClient.get_webhook_secret(provider_config),
+            settings.creem_test_webhook_secret,
+            settings.creem_prod_webhook_secret,
+            provider_config.get("webhook_secret") if provider_config else None,
+            provider_config.get("test_webhook_secret") if provider_config else None,
+            provider_config.get("prod_webhook_secret") if provider_config else None,
+        ] if s
+    ]
+    if not candidate_secrets:
+        logger.error("❌ [CREEM] Webhook secret is not configured for current environment (%s)", settings.env)
+        raise HTTPException(status_code=500, detail="Creem webhook secret is not configured")
 
-    # 如果配置了 secret 则进行防篡改验签
-    if webhook_secret:
-        if not verify_creem_signature(payload, sig_header, webhook_secret):
-            logger.error("❌ [CREEM] Webhook signature invalid: signature=%s", sig_header)
-            raise HTTPException(status_code=400, detail="Invalid Creem signature")
-    else:
-        logger.warning("⚠️ [CREEM] Webhook secret not set, skipping signature verification in current mode")
+    if not verify_creem_signature(payload, sig_header, candidate_secrets):
+        logger.error("❌ [CREEM] Webhook signature invalid: signature=%s", sig_header)
+        raise HTTPException(status_code=400, detail="Invalid Creem signature")
 
     try:
         event = json.loads(payload.decode("utf-8"))

+ 59 - 8
app/core/config.py

@@ -8,7 +8,7 @@ class Settings(BaseSettings):
     # App
     # -----------------------
     app_name: str = "MyApp"
-    env: str = "PROD"
+    env: str = "PROD"  # DEV (测试/开发环境) | PROD (生产正式环境)
     debug: bool = False
 
     # -----------------------
@@ -17,15 +17,66 @@ class Settings(BaseSettings):
     database_url: str = Field(..., description="Async database DSN")
     redis_url: str
 
+    @property
+    def is_prod(self) -> bool:
+        """全局判断是否为生产环境"""
+        return str(self.env).strip().upper() in ("PROD", "PRODUCTION", "LIVE")
+
+    @property
+    def is_dev(self) -> bool:
+        """全局判断是否为测试/开发环境"""
+        return not self.is_prod
+
+    # -----------------------
+    # Stripe 配置 (生产 / 测试)
+    # -----------------------
+    stripe_prod_api_key: str = Field("", description="Stripe Production API Key")
+    stripe_prod_webhook_secret: str = Field("", description="Stripe Production Webhook Secret")
+    stripe_test_api_key: str = Field("", description="Stripe Test API Key")
+    stripe_test_webhook_secret: str = Field("", description="Stripe Test Webhook Secret")
+
+    # -----------------------
+    # Creem 配置 (生产 / 测试)
     # -----------------------
-    # Security / API Keys
+    creem_prod_api_key: str = Field("", description="Creem Production API Key")
+    creem_prod_webhook_secret: str = Field("", description="Creem Production Webhook Secret")
+    creem_prod_base_url: str = Field("https://api.creem.io", description="Creem Production Base URL")
+    creem_prod_product_id: str = Field("", description="Creem Production Product ID")
+
+    creem_test_api_key: str = Field("", description="Creem Test API Key")
+    creem_test_webhook_secret: str = Field("", description="Creem Test Webhook Secret")
+    creem_test_base_url: str = Field("https://test-api.creem.io", description="Creem Test Base URL")
+    creem_test_product_id: str = Field("", description="Creem Test Product ID")
+
     # -----------------------
-    stripe_api_key: str
-    stripe_webhook_secret: str
-    creem_api_key: str = Field("", description="Creem API Key")
-    creem_webhook_secret: str = Field("", description="Creem Webhook Secret")
-    creem_base_url: str = Field("https://test-api.creem.io", description="Creem Base URL (or https://api.creem.io)")
-    creem_product_id: str = Field("", description="Default Creem Product ID (optional)")
+    # 确定性环境属性(根据 ENV 确定使用生产还是测试值)
+    # -----------------------
+    @property
+    def active_stripe_api_key(self) -> str:
+        return self.stripe_prod_api_key if self.is_prod else self.stripe_test_api_key
+
+    @property
+    def active_stripe_webhook_secret(self) -> str:
+        return self.stripe_prod_webhook_secret if self.is_prod else self.stripe_test_webhook_secret
+
+    @property
+    def active_creem_api_key(self) -> str:
+        return self.creem_prod_api_key if self.is_prod else self.creem_test_api_key
+
+    @property
+    def active_creem_webhook_secret(self) -> str:
+        return self.creem_prod_webhook_secret if self.is_prod else self.creem_test_webhook_secret
+
+    @property
+    def active_creem_base_url(self) -> str:
+        if self.is_prod:
+            return (self.creem_prod_base_url or "https://api.creem.io").rstrip("/")
+        return (self.creem_test_base_url or "https://test-api.creem.io").rstrip("/")
+
+    @property
+    def active_creem_product_id(self) -> str:
+        return self.creem_prod_product_id if self.is_prod else self.creem_test_product_id
+
     telegram_api_token: str = Field("", description="Telegram bot API token")
     wechat_api_token: str = Field("", description="Wechat webhook API token")
     whatsapp_api_base_url: str = Field("https://waha.text.skin", description="Whatsapp API base url")

+ 55 - 25
app/core/creem.py

@@ -11,20 +11,27 @@ from app.core.logger import logger
 from app.core.biz_exception import BizLogicError
 
 
-def verify_creem_signature(payload_bytes: bytes, signature: str, secret: str) -> bool:
+def verify_creem_signature(payload_bytes: bytes, signature: str, secret_or_secrets: Any) -> bool:
     """
     验证 Creem Webhook 签名 (HMAC-SHA256)
     Creem 发送 creem-signature 头部,为 HEX 格式
+    支持单个 secret 字符串或候选 secrets 列表(生产+测试)
     """
-    if not signature or not secret:
-        return False
-    try:
-        computed = hmac.new(secret.encode("utf-8"), payload_bytes, hashlib.sha256).hexdigest()
-        return hmac.compare_digest(computed.lower(), signature.strip().lower())
-    except Exception as e:
-        logger.error(f"❌ [CREEM] Webhook signature verification error: {e}")
+    if not signature or not secret_or_secrets:
         return False
 
+    secrets = [secret_or_secrets] if isinstance(secret_or_secrets, str) else list(secret_or_secrets)
+    for sec in secrets:
+        if not sec:
+            continue
+        try:
+            computed = hmac.new(sec.encode("utf-8"), payload_bytes, hashlib.sha256).hexdigest()
+            if hmac.compare_digest(computed.lower(), signature.strip().lower()):
+                return True
+        except Exception as e:
+            logger.error(f"❌ [CREEM] Webhook signature verification error: {e}")
+    return False
+
 
 class CreemClient:
     """
@@ -32,25 +39,44 @@ class CreemClient:
     Official documentation: https://docs.creem.io/code/sdks/ai-agents
     """
 
+    @classmethod
+    def is_prod_mode(cls) -> bool:
+        """
+        根据全局环境变量 ENV 控制整个系统是生产还是测试:
+        - ENV='PROD' (或 prod/production) -> 生产正式环境,走生产配置
+        - ENV='DEV' (或 dev/test/local) -> 测试环境,走测试配置
+        """
+        return settings.is_prod
+
+    @classmethod
+    def is_test_environment(cls, provider_config: Optional[Dict[str, Any]] = None) -> bool:
+        return not cls.is_prod_mode()
+
     @classmethod
     def get_api_key(cls, provider_config: Optional[Dict[str, Any]] = None) -> str:
-        if provider_config and provider_config.get("api_key"):
-            return provider_config["api_key"]
-        return settings.creem_api_key
+        """根据当前全局 ENV 确定性返回 API Key"""
+        return settings.active_creem_api_key
 
     @classmethod
-    def get_base_url(cls, provider_config: Optional[Dict[str, Any]] = None) -> str:
-        if provider_config and provider_config.get("base_url"):
-            return provider_config["base_url"].rstrip("/")
-        if provider_config and provider_config.get("test_mode") is False:
-            return "https://api.creem.io"
-        return settings.creem_base_url.rstrip("/") or "https://test-api.creem.io"
+    def get_base_url(cls, provider_config: Optional[Dict[str, Any]] = None, api_key: str = "") -> str:
+        """根据当前全局 ENV 确定性返回 Base URL"""
+        return settings.active_creem_base_url
 
     @classmethod
     def get_webhook_secret(cls, provider_config: Optional[Dict[str, Any]] = None) -> str:
-        if provider_config and provider_config.get("webhook_secret"):
-            return provider_config["webhook_secret"]
-        return settings.creem_webhook_secret
+        """根据当前全局 ENV 确定性返回 Webhook Secret"""
+        return settings.active_creem_webhook_secret
+
+    @classmethod
+    def get_product_id(cls, provider_config: Optional[Dict[str, Any]] = None) -> str:
+        """根据当前全局 ENV 确定性返回 Product ID"""
+        return settings.active_creem_product_id
+
+    @classmethod
+    def get_webhook_secrets(cls, provider_config: Optional[Dict[str, Any]] = None) -> list[str]:
+        """获取当前全局 ENV 的 Webhook Secret"""
+        secret = cls.get_webhook_secret(provider_config)
+        return [secret] if secret else []
 
     @classmethod
     async def create_product(
@@ -59,7 +85,7 @@ class CreemClient:
         price_cents: int,
         currency: str = "USD",
         description: Optional[str] = None,
-        billing_type: str = "one_time",
+        billing_type: str = "onetime",
         provider_config: Optional[Dict[str, Any]] = None,
     ) -> Dict[str, Any]:
         """
@@ -67,7 +93,7 @@ class CreemClient:
         POST /v1/products
         """
         api_key = cls.get_api_key(provider_config)
-        base_url = cls.get_base_url(provider_config)
+        base_url = cls.get_base_url(provider_config, api_key=api_key)
 
         if not api_key:
             raise BizLogicError("Creem API Key is not configured")
@@ -77,14 +103,18 @@ class CreemClient:
             "x-api-key": api_key,
             "Content-Type": "application/json",
         }
+
+        # Creem API 要求 billing_type 枚举必须为 'onetime' 或 'recurring'
+        clean_billing_type = "recurring" if "recur" in billing_type.lower() else "onetime"
+        desc = (description or f"{name} Application Service").strip()[:500]
+
         payload = {
             "name": name,
             "price": price_cents,
             "currency": currency.upper(),
-            "billing_type": billing_type,
+            "billing_type": clean_billing_type,
+            "description": desc,
         }
-        if description:
-            payload["description"] = description[:500]
 
         logger.info(f"💳 [CREEM] Creating product on {url}: name={name} price={price_cents} {currency}")
 

+ 7 - 0
app/core/migration.py

@@ -63,6 +63,13 @@ async def run_settlement_migrations(conn: AsyncConnection):
             logger.info("➕ [MIGRATION] Adding column 'protocol' to table 'plugins'...")
             await conn.execute(text("ALTER TABLE plugins ADD COLUMN protocol VARCHAR(64) NOT NULL DEFAULT 'IPlugin' COMMENT '插件协议标识' AFTER class_name"))
 
+        # 4. 检查 vas_payment 表 provider 列类型是否已扩充支持 creem 等新渠道
+        res_pay = await conn.execute(text("SHOW COLUMNS FROM vas_payment LIKE 'provider'"))
+        pay_col = res_pay.fetchone()
+        if pay_col and "enum" in str(pay_col[1]).lower():
+            logger.info("➕ [MIGRATION] Modifying 'provider' column in 'vas_payment' to VARCHAR(64)...")
+            await conn.execute(text("ALTER TABLE vas_payment MODIFY COLUMN provider VARCHAR(64) NOT NULL COMMENT '支付服务商: stripe, wechat, alipay, creem'"))
+
         logger.info("✅ [MIGRATION] Settlement & Plugin schema migration completed successfully.")
     except Exception as e:
         logger.error(f"❌ [MIGRATION ERROR] Failed to run settlement migrations: {e}", exc_info=True)

+ 4 - 1
app/core/payment.py

@@ -3,4 +3,7 @@ import stripe
 from app.core.config import settings
 
 def init_stripe():
-    stripe.api_key = settings.stripe_api_key
+    if settings.is_prod:
+        stripe.api_key = settings.stripe_prod_api_key or settings.stripe_api_key
+    else:
+        stripe.api_key = settings.stripe_test_api_key or settings.stripe_api_key

+ 1 - 1
app/models/payment.py

@@ -39,7 +39,7 @@ class VasPayment(Base):
     id = Column(Integer, primary_key=True, autoincrement=True)
     order_id = Column(String(128), nullable=False)
 
-    provider = Column(Enum('stripe', 'wechat', 'alipay'), nullable=False)
+    provider = Column(String(64), nullable=False)
     channel = Column(String(50), nullable=False)
     
     # 支付意向ID (Stripe PaymentIntent ID)

+ 15 - 1
app/schemas/order.py

@@ -32,7 +32,21 @@ class VasOrderCreateAdmin(BaseModel):
     channel_type: Optional[Literal['direct', 'agency', 'website']] = 'direct'
     agency_id: Optional[str] = None
     handler_id: Optional[str] = None
-    final_amount: Optional[int] = None  # 管理员若自定义价格(分)
+    final_amount: Optional[int] = None  # 约定金额 / 实收金额 (分)
+    payment_timing: Optional[Literal['pay_later', 'paid_now']] = 'pay_later'  # 先办后付 vs 当场现结
+    payment_method: Optional[str] = None  # wechat, alipay, bank_transfer, cash, offline
+    external_trade_no: Optional[str] = None
+    voucher_url: Optional[str] = None
+    payment_note: Optional[str] = None
+
+
+class VasOrderRegisterPayment(BaseModel):
+    order_id: str
+    amount: int  # 实收金额 (分)
+    payment_method: str = "wechat"  # wechat, alipay, bank_transfer, cash, offline
+    external_trade_no: Optional[str] = None
+    voucher_url: Optional[str] = None
+    note: Optional[str] = None
 
 
 class VasOrderUpdate(BaseModel):

+ 1 - 1
app/schemas/payment.py

@@ -26,7 +26,7 @@ class VasPaymentBase(BaseModel):
     
 class VasPaymentCreate(BaseModel):
     order_id: str
-    provider: Literal['stripe', 'wechat', 'alipay']
+    provider: str
     
 class AdminUpdateStatusPayload(BaseModel):
     remark: Optional[str] = None

+ 147 - 5
app/services/order_service.py

@@ -18,7 +18,7 @@ from app.models.vas_task import VasTask
 from app.models.product import VasProduct
 from app.models.payment import VasPayment
 from app.models.agency import VasAgency
-from app.schemas.order import VasOrderCreate, VasOrderCreateAdmin, VasOrderAdjustPrice, VasOrderPatchUserInputs, VasOrderUpdate
+from app.schemas.order import VasOrderCreate, VasOrderCreateAdmin, VasOrderAdjustPrice, VasOrderPatchUserInputs, VasOrderUpdate, VasOrderRegisterPayment
 from app.services.webhook_service import WebhookService
 from app.services.agency_service import AgencyService
 
@@ -78,8 +78,11 @@ class OrderService:
         channel_type = data.channel_type or "direct"
         agency_id = data.agency_id if channel_type == "agency" else None
         
-        # 确定金额
+        # 确定金额与收款时机
         final_amount = data.final_amount if (data.final_amount is not None and data.final_amount > 0) else product.price_amount
+        timing = getattr(data, "payment_timing", "pay_later") or "pay_later"
+        is_paid_now = (timing == "paid_now")
+        initial_status = "paid" if is_paid_now else "pending"
 
         # 渠道判定与底价拦截
         if channel_type == "agency":
@@ -108,7 +111,7 @@ class OrderService:
             id=order_id,
             product_id=data.product_id,
             user_inputs=data.user_inputs,
-            status="paid",
+            status=initial_status,
             product_name=safe_product_name,
             base_amount=product.price_amount,
             base_currency=product.price_currency,
@@ -122,7 +125,7 @@ class OrderService:
             settlement_status='unsettled',
         )
 
-        # ===== user_inputs 安全修复 =====
+        # ===== user_inputs 安全修复与审计 =====
         raw_inputs = order.user_inputs
         if isinstance(raw_inputs, str):
             try:
@@ -139,14 +142,153 @@ class OrderService:
             "reason": "admin manual order",
             "channel_type": channel_type,
             "handler_id": handler_id,
+            "payment_timing": timing,
         }
         
         db.add(order)
+
+        # 若当场全款已付,则同步生成核销入账流水
+        if is_paid_now:
+            provider = data.payment_method or "offline"
+            payment = VasPayment(
+                order_id=order.id,
+                provider=provider,
+                channel="admin_manual",
+                payment_intent_id=f"MANUAL-{datetime.utcnow():%Y%m%d%H%M%S}-{uuid.uuid4().hex[:6]}",
+                external_trade_no=data.external_trade_no,
+                status="succeeded",
+                base_amount=product.price_amount,
+                adjustment_delta=final_amount - product.price_amount,
+                final_amount=final_amount,
+                base_currency=product.price_currency,
+                amount=final_amount,
+                currency=product.price_currency,
+                random_offset=0,
+                exchange_rate=1.0,
+                provider_payload={
+                    "timing": "paid_now",
+                    "note": data.payment_note or "代客录单当场全款结清",
+                    "voucher_url": data.voucher_url,
+                    "registered_by": auth_user.id,
+                    "registered_by_name": getattr(auth_user, "name", auth_user.id),
+                    "registered_at": datetime.utcnow().isoformat(),
+                },
+            )
+            db.add(payment)
+
+            # 记录收款凭证审计记录至订单 user_inputs
+            user_inputs = dict(order.user_inputs or {})
+            history = list(user_inputs.get("_payments_history", []))
+            history.append({
+                "amount": final_amount,
+                "provider": provider,
+                "external_trade_no": data.external_trade_no,
+                "voucher_url": data.voucher_url,
+                "note": data.payment_note or "代客录单当场全款结清",
+                "by": auth_user.id,
+                "at": datetime.utcnow().isoformat(),
+            })
+            user_inputs["_payments_history"] = history
+            order.user_inputs = user_inputs
+
+        # 无论先办后付还是当场现结,抢单任务均立即入队调度!
         await WebhookService._create_task_if_not_exists(db, order)
         
         await db.commit()
         await db.refresh(order)
-        logger.info(f"👑 [ORDER] Admin created order: id={order.id} product={product.id} channel={channel_type} handler={handler_id} amount={final_amount}")
+        logger.info(f"👑 [ORDER] Admin created order: id={order.id} product={product.id} channel={channel_type} timing={timing} status={initial_status} amount={final_amount}")
+        return order
+
+    @staticmethod
+    async def register_payment(
+        db: AsyncSession,
+        payload: VasOrderRegisterPayment,
+        current_user: VasUser,
+    ) -> VasOrder:
+        """
+        管理员/客服对订单进行实收金额登记与核销入账 (适用于先办后付尾款或线下补款)
+        """
+        stmt = select(VasOrder).where(VasOrder.id == payload.order_id)
+        order = (await db.execute(stmt)).scalar_one_or_none()
+        if not order:
+            raise NotFoundError(f"Order not found: {payload.order_id}")
+
+        if payload.amount <= 0:
+            raise BizLogicError("Payment amount must be greater than 0")
+
+        # 检查中介底价拦截
+        if order.channel_type == "agency" and order.agency_id:
+            agency = await AgencyService.get(db, order.agency_id)
+            if agency and agency.min_floor_price > 0 and payload.amount < agency.min_floor_price:
+                raise BizLogicError(
+                    f"Registered amount (¥{payload.amount/100:.2f}) is below agency minimum floor settlement price (¥{agency.min_floor_price/100:.2f})"
+                )
+
+        order.final_amount = payload.amount
+        order.adjustment_delta = payload.amount - order.base_amount
+
+        # 状态流转: 若原先为 pending 待付款,直接转为 paid
+        if order.status == "pending":
+            order.status = "paid"
+        
+        # 若订单已是 completed 状态,且此前未进入 eligible,更新为 eligible
+        if order.status == "completed" and order.settlement_status == "unsettled":
+            order.settlement_status = "eligible"
+
+        # 生成成功支付流水记录
+        payment = VasPayment(
+            order_id=order.id,
+            provider=payload.payment_method or "offline",
+            channel="admin_manual",
+            payment_intent_id=f"MANUAL-{datetime.utcnow():%Y%m%d%H%M%S}-{uuid.uuid4().hex[:6]}",
+            external_trade_no=payload.external_trade_no,
+            status="succeeded",
+            base_amount=order.base_amount,
+            adjustment_delta=order.adjustment_delta,
+            final_amount=payload.amount,
+            base_currency=order.base_currency,
+            amount=payload.amount,
+            currency=order.base_currency,
+            random_offset=0,
+            exchange_rate=1.0,
+            provider_payload={
+                "timing": "post_pay_registered",
+                "note": payload.note or "代客下单后置收款登记",
+                "voucher_url": payload.voucher_url,
+                "registered_by": current_user.id,
+                "registered_by_name": getattr(current_user, "name", current_user.id),
+                "registered_at": datetime.utcnow().isoformat(),
+            },
+        )
+        db.add(payment)
+
+        # 审计日志追加
+        user_inputs = order.user_inputs or {}
+        if not isinstance(user_inputs, dict):
+            try:
+                user_inputs = json.loads(user_inputs)
+            except Exception:
+                user_inputs = {}
+
+        history = user_inputs.get("_payments_history", [])
+        history.append({
+            "amount": payload.amount,
+            "provider": payload.payment_method,
+            "external_trade_no": payload.external_trade_no,
+            "voucher_url": payload.voucher_url,
+            "note": payload.note,
+            "by": current_user.id,
+            "at": datetime.utcnow().isoformat(),
+        })
+        user_inputs["_payments_history"] = history
+        order.user_inputs = user_inputs
+
+        await db.commit()
+        await db.refresh(order)
+        logger.info(
+            f"💰 [ORDER] Registered payment for order {order.id}: "
+            f"amount={payload.amount} method={payload.payment_method} by={current_user.id}"
+        )
         return order
 
     @staticmethod

+ 2 - 2
app/services/payment_service.py

@@ -572,7 +572,7 @@ class PaymentService:
             user_email = user.email
 
         # 检查是否已有配置好的 product_id,没有则向 Creem 动态创建
-        creem_product_id = provider_config.get("product_id") or settings.creem_product_id
+        creem_product_id = CreemClient.get_product_id(provider_config)
         if not creem_product_id:
             product_name = f"Visa Service #{order.id}"
             prod_data = await CreemClient.create_product(
@@ -580,7 +580,7 @@ class PaymentService:
                 price_cents=payment.amount,
                 currency=payment.currency,
                 description=f"Visa Application Service Order #{order.id}",
-                billing_type="one_time",
+                billing_type="onetime",
                 provider_config=provider_config,
             )
             creem_product_id = prod_data.get("id")

+ 9 - 9
app/services/settlement_service.py

@@ -76,15 +76,15 @@ class SettlementService:
         partner_b = (req.partner_b_id or "").strip()
 
         if not partner_a:
-            raise BizLogicError("请提供合伙人甲方的系统用户ID (partner_a_id),结算系统不使用任何预设值!")
+            raise BizLogicError("Please provide system user ID for Partner A (partner_a_id). The settlement system does not use default presets.")
         if not partner_b:
-            raise BizLogicError("请提供合伙人乙方的系统用户ID (partner_b_id),结算系统不使用任何预设值!")
+            raise BizLogicError("Please provide system user ID for Partner B (partner_b_id). The settlement system does not use default presets.")
         if partner_a not in users_map:
-            raise BizLogicError(f"指定的合伙人甲方用户ID【{partner_a}】在系统用户表中不存在!")
+            raise BizLogicError(f"Specified Partner A user ID '{partner_a}' does not exist in the system users table.")
         if partner_b not in users_map:
-            raise BizLogicError(f"指定的合伙人乙方用户ID【{partner_b}】在系统用户表中不存在!")
+            raise BizLogicError(f"Specified Partner B user ID '{partner_b}' does not exist in the system users table.")
         if partner_a == partner_b:
-            raise BizLogicError("合伙人甲方与乙方不能为同一用户!")
+            raise BizLogicError("Partner A and Partner B cannot be the same user.")
 
         # 预加载当前账期涉及的所有商品与插件,技术分成按订单绑定的商品及处理插件开发管理者自动归属
         product_ids = {o.product_id for o in orders if o.product_id}
@@ -116,7 +116,7 @@ class SettlementService:
             # 2. 从订单绑定的商品中解析
             if not o.product_id or o.product_id not in products_map:
                 raise BizLogicError(
-                    f"订单 #{o.id} 未关联有效商品 (product_id={o.product_id}),无法核算技术分成,请先完善订单商品关联!"
+                    f"Order #{o.id} is not associated with a valid product (product_id={o.product_id}). Technical share cannot be calculated without product association."
                 )
 
             prod = products_map[o.product_id]
@@ -139,13 +139,13 @@ class SettlementService:
 
             if not pl:
                 raise BizLogicError(
-                    f"订单 #{o.id} 所属商品【{prod.title}】(商品ID: {prod.id}) 尚未绑定履约处理插件,无法计算技术分成!请先在「商品管理」编辑弹窗中绑定对应插件后再进行结算。"
+                    f"Product '{prod.title}' (ID: {prod.id}) for order #{o.id} is not bound to an execution plugin. Please bind a plugin in Product Management before settling."
                 )
 
             # 2.3 从绑定的插件中提取 developer_id,且必须为系统真实用户
             if not getattr(pl, 'developer_id', None) or not pl.developer_id.strip():
                 raise BizLogicError(
-                    f"商品【{prod.title}】绑定的插件【{pl.name} ({pl.display_name})】尚未配置技术开发管理者 (developer_id),无法计算技术分成!请先在「插件管理」中完善开发者配置。"
+                    f"Plugin '{pl.name} ({pl.display_name})' bound to product '{prod.title}' has no developer_id configured. Please configure a developer in Plugin Management before settling."
                 )
 
             dev_candidate = pl.developer_id.strip()
@@ -156,7 +156,7 @@ class SettlementService:
                     return u.id
 
             raise BizLogicError(
-                f"商品【{prod.title}】绑定的插件【{pl.name}】所配置的开发者ID【{dev_candidate}】在系统用户表中不存在,无法结算技术分成!"
+                f"Developer ID '{dev_candidate}' configured for plugin '{pl.name}' on product '{prod.title}' does not exist in system users table."
             )
 
         # 临时聚合各人的毛利润

+ 0 - 356
app/services/statistics_service.py

@@ -1,356 +0,0 @@
-# app/services/statistics_service.py
-
-import json
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import func, desc, case, select
-from datetime import datetime, timedelta, date
-from typing import Dict, Any, Tuple
-
-from app.models.order import VasOrder
-from app.models.ticket import VasTicket
-from app.models.vas_task import VasTask
-from app.models.user import VasUser
-from app.models.product import VasProduct
-from app.models.configuration import Configuration
-
-# ======================
-# 货币符号 (仅用于展示文本,无需存库)
-# ======================
-CURRENCY_SYMBOLS = {
-    "CNY": "¥", "USD": "$", "EUR": "€", "GBP": "£", "HKD": "HK$", "JPY": "¥"
-}
-
-class StatisticsService:
-
-    # ======================
-    # 辅助方法:汇率与时间
-    # ======================
-
-    @staticmethod
-    async def _get_exchange_rates(db: AsyncSession) -> Dict[str, float]:
-        """
-        从数据库获取动态汇率配置
-        返回格式示例: {'CNY': 1.0, 'USD': 7.25, ...}
-        """
-        stmt = select(Configuration).where(Configuration.config_key == "EXCHANGE_RATES")
-        config_obj = (await db.execute(stmt)).scalar_one_or_none()
-        
-        # 默认兜底汇率
-        fallback_rates = {"CNY": 1.0}
-
-        if not config_obj:
-            return fallback_rates
-        
-        try:
-            val = config_obj.config_value
-            data = {}
-            if isinstance(val, str):
-                data = json.loads(val)
-            elif isinstance(val, dict):
-                data = val
-            
-            return data.get("rates", fallback_rates)
-        except Exception:
-            return fallback_rates
-
-    @staticmethod
-    def _convert_to_cny(amount: Any, currency: str, rates: Dict[str, float]) -> int:
-        """
-        金额(分) → CNY(分)
-        """
-        if not amount:
-            return 0
-        rate = float(rates.get(currency, 1.0))
-        return int(float(amount) * rate)
-
-    @staticmethod
-    def _get_month_ranges() -> Tuple[datetime, datetime, datetime, datetime]:
-        """
-        获取时间范围用于环比计算
-        返回: (本月开始, 本月结束, 上月开始, 上月结束)
-        """
-        now = datetime.now()
-        
-        # 本月范围
-        this_month_start = now.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
-        this_month_end = now  # 截止到当前时间
-
-        # 上月范围
-        # 上月结束 = 本月开始 - 1微秒
-        last_month_end_dt = this_month_start - timedelta(microseconds=1)
-        # 上月开始
-        last_month_start = last_month_end_dt.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
-        
-        # 为了公平比较(如果需要),可以将上月结束时间也限制在和本月同样的天数进度
-        # 但通常简易报表直接对比 上月全月总额 vs 本月至今总额,或者对比 上月至今
-        # 这里采用简单的 上月全月 vs 本月至今
-        
-        return this_month_start, this_month_end, last_month_start, last_month_end_dt
-
-    @staticmethod
-    def _calculate_growth(current: float, previous: float) -> float:
-        """计算增长率百分比"""
-        if previous == 0:
-            return 100.0 if current > 0 else 0.0
-        return ((current - previous) / previous) * 100.0
-
-    # ======================
-    # 核心接口
-    # ======================
-
-    @staticmethod
-    async def overview(db: AsyncSession) -> Dict[str, Any]:
-        """
-        后台统计概览(Async 版)
-        """
-
-        # 0. 准备基础数据
-        current_rates = await StatisticsService._get_exchange_rates(db)
-        tm_start, tm_end, lm_start, lm_end = StatisticsService._get_month_ranges()
-
-        # --------------------------------------------------
-        # 1. 营收统计 (本月 vs 上月) - 用于计算 Trend
-        # --------------------------------------------------
-        
-        async def calculate_revenue(start_dt, end_dt):
-            stmt = (
-                select(VasOrder.base_currency, func.sum(VasOrder.base_amount))
-                .where(
-                    VasOrder.created_at >= start_dt,
-                    VasOrder.created_at <= end_dt,
-                    VasOrder.status.in_(["paid", "completed", "succeeded"])
-                )
-                .group_by(VasOrder.base_currency)
-            )
-            rows = (await db.execute(stmt)).all()
-            total_cny = sum(
-                StatisticsService._convert_to_cny(amt, curr, current_rates)
-                for curr, amt in rows
-            )
-            return total_cny
-
-        revenue_this_month = await calculate_revenue(tm_start, tm_end)
-        revenue_last_month = await calculate_revenue(lm_start, lm_end)
-        
-        revenue_trend = StatisticsService._calculate_growth(revenue_this_month, revenue_last_month)
-
-        # --------------------------------------------------
-        # 2. 订单量统计 (本月 vs 上月) - 用于计算 Trend
-        # --------------------------------------------------
-
-        async def calculate_orders(start_dt, end_dt):
-            count = await db.scalar(
-                select(func.count(VasOrder.id))
-                .where(
-                    VasOrder.created_at >= start_dt,
-                    VasOrder.created_at <= end_dt,
-                    VasOrder.status.in_(["paid", "completed", "succeeded"]) # 仅统计有效订单
-                )
-            )
-            return count or 0
-
-        orders_this_month = await calculate_orders(tm_start, tm_end)
-        orders_last_month = await calculate_orders(lm_start, lm_end)
-
-        orders_trend = StatisticsService._calculate_growth(orders_this_month, orders_last_month)
-
-        # --------------------------------------------------
-        # 3. 其他静态指标
-        # --------------------------------------------------
-
-        # 活跃用户数 (总累计)
-        active_users = (
-            await db.scalar(select(func.count(VasUser.id)))
-        ) or 0
-
-        # 待处理工单
-        pending_tickets = (
-            await db.scalar(
-                select(func.count(VasTicket.id))
-                .where(VasTicket.status.in_(["pending", "info_required"]))
-            )
-        ) or 0
-
-        # 任务成功率
-        task_stmt = select(
-            func.count(VasTask.id).label("total"),
-            func.sum(
-                case((VasTask.status == "completed", 1), else_=0)
-            ).label("success")
-        )
-        task_counts = (await db.execute(task_stmt)).first()
-
-        success_rate_str = "0%"
-        if task_counts and task_counts.total > 0:
-            rate = (task_counts.success / task_counts.total) * 100
-            success_rate_str = f"{rate:.1f}%"
-
-        # --------------------------------------------------
-        # 4. 图表数据:最近 7 天营收趋势
-        # --------------------------------------------------
-
-        revenue_trend_chart = []
-        today = date.today()
-
-        for i in range(6, -1, -1):
-            target_date = today - timedelta(days=i)
-            start_dt = datetime.combine(target_date, datetime.min.time())
-            end_dt = datetime.combine(target_date, datetime.max.time())
-
-            daily_stmt = (
-                select(
-                    VasOrder.base_currency,
-                    func.sum(VasOrder.base_amount).label("amount"),
-                    func.count(VasOrder.id).label("orders")
-                )
-                .where(
-                    VasOrder.created_at >= start_dt,
-                    VasOrder.created_at <= end_dt,
-                    VasOrder.status.in_(["paid", "completed", "succeeded"])
-                )
-                .group_by(VasOrder.base_currency)
-            )
-
-            daily_rows = (await db.execute(daily_stmt)).all()
-
-            daily_amount_cny = 0
-            daily_order_count = 0
-
-            for curr, amt, cnt in daily_rows:
-                daily_amount_cny += StatisticsService._convert_to_cny(amt, curr, current_rates)
-                daily_order_count += cnt
-
-            revenue_trend_chart.append({
-                "date": target_date.strftime("%m-%d"),
-                "amount": daily_amount_cny / 100.0, # 转为元
-                "orders": daily_order_count
-            })
-
-        # --------------------------------------------------
-        # 5. 商品销量分布(Top 5)
-        # --------------------------------------------------
-
-        product_stmt = (
-            select(
-                VasProduct.title,
-                func.count(VasOrder.id).label("count")
-            )
-            .join(VasOrder, VasOrder.product_id == VasProduct.id)
-            .where(VasOrder.status.in_(["paid", "completed", "succeeded"]))
-            .group_by(VasProduct.title)
-            .order_by(desc("count"))
-            .limit(5)
-        )
-
-        product_rows = (await db.execute(product_stmt)).all()
-        product_dist = [
-            {"name": title, "value": count}
-            for title, count in product_rows
-        ]
-
-        # --------------------------------------------------
-        # 6. 最新动态 (混合订单和工单)
-        # --------------------------------------------------
-
-        activities = []
-
-        # 最近订单
-        order_stmt = (
-            select(VasOrder)
-            .order_by(desc(VasOrder.created_at))
-            .limit(5)
-        )
-        recent_orders = (await db.execute(order_stmt)).scalars().all()
-
-        for o in recent_orders:
-            # 动态仅作展示,这里使用原始币种即可,不需要转CNY
-            symbol = CURRENCY_SYMBOLS.get(o.base_currency, o.base_currency)
-            amt_display = f"{symbol}{o.base_amount / 100}"
-
-            activities.append({
-                "id": f"order_{o.id}",
-                "text": f"用户下单: {o.product_name or '未知商品'} ({amt_display})",
-                "time": o.created_at,
-                "type": "order" if o.status == "pending" else "money"
-            })
-
-        # 最近工单
-        ticket_stmt = (
-            select(VasTicket)
-            .order_by(desc(VasTicket.created_at))
-            .limit(5)
-        )
-        recent_tickets = (await db.execute(ticket_stmt)).scalars().all()
-
-        for t in recent_tickets:
-            reason_preview = (
-                t.reason[:20] + "..."
-                if t.reason and len(t.reason) > 20
-                else t.reason
-            )
-            activities.append({
-                "id": f"ticket_{t.id}",
-                "text": f"新工单 #{t.id}: {reason_preview}",
-                "time": t.created_at,
-                "type": "ticket"
-            })
-
-        # 按时间倒序排序
-        activities.sort(key=lambda x: x["time"], reverse=True)
-        activities = activities[:10]
-
-        # 格式化时间显示
-        now_dt = datetime.now()
-        for act in activities:
-            dt = act["time"]
-            diff = now_dt - dt
-            if diff.days > 0:
-                act["time"] = f"{diff.days}天前"
-            elif diff.seconds > 3600:
-                act["time"] = f"{diff.seconds // 3600}小时前"
-            elif diff.seconds > 60:
-                act["time"] = f"{diff.seconds // 60}分钟前"
-            else:
-                act["time"] = "刚刚"
-                
-        active_task_stmt = (
-            select(
-                VasTask.routing_key, 
-                func.count(VasTask.id).label("count")
-            )
-            .where(
-                VasTask.status.in_(["pending", "grabbed", "running"])
-            )
-            .group_by(VasTask.routing_key)
-            .order_by(desc("count")) # 按数量倒序排列
-        )
-
-        active_task_rows = (await db.execute(active_task_stmt)).all()
-        
-        # 组装为 List[ActiveTaskGroupItem] 格式
-        active_tasks_dist_data = [
-            {"routing_key": r_key, "count": count} 
-            for r_key, count in active_task_rows
-        ]
-
-        # --------------------------------------------------
-        # 7. 组装返回结果
-        # --------------------------------------------------
-
-        return {
-            "stats": {
-                "totalOrders": orders_this_month,       # 仅显示本月,为了匹配趋势语境
-                "totalOrdersTrend": orders_trend,       # 新增:订单增长率
-                
-                "totalRevenue": revenue_this_month,     # 仅显示本月营收 (分)
-                "totalRevenueTrend": revenue_trend,     # 新增:营收增长率
-                
-                "activeUsers": active_users,
-                "pendingTickets": pending_tickets,
-                "successRate": success_rate_str
-            },
-            "revenue_trend": revenue_trend_chart,       # 图表数据
-            "product_dist": product_dist,               # 饼图数据
-            "recent_activities": activities,            # 动态列表
-            "active_tasks_dist": active_tasks_dist_data
-        }

+ 3 - 3
app/services/webhook_service.py

@@ -373,9 +373,9 @@ class WebhookService:
         event: dict,
     ) -> Optional[PaymentWebhookOut]:
 
-        event_id = event.get("id")
-        event_type = event.get("eventType")
-        obj = event.get("object", {})
+        event_id = event.get("id") or event.get("event_id")
+        event_type = event.get("eventType") or event.get("event") or event.get("type")
+        obj = event.get("object") or event.get("data") or event
 
         if not event_id:
             logger.error("❌ [WEBHOOK] Missing event id in Creem webhook")

+ 50 - 19
app/utils/validation_utils.py

@@ -1,27 +1,58 @@
+import re
 from jsonschema import validate, ValidationError
-from app.core.biz_exception import NotFoundError, PermissionDeniedError, BizLogicError
+from app.core.biz_exception import BizLogicError
 
-from jsonschema import validate, ValidationError
 
 def validate_user_inputs(schema_json: dict, user_inputs: dict):
+    """
+    Validate user inputs against the product's JSON Schema.
+    Produces clear, human-readable English error messages identifying the exact field.
+    """
+    if not schema_json:
+        return
+    if user_inputs is None:
+        user_inputs = {}
+    if not isinstance(user_inputs, dict):
+        raise BizLogicError(f"Invalid parameter [root]: Expected object, got {type(user_inputs).__name__}")
+
     try:
         validate(instance=user_inputs, schema=schema_json)
     except ValidationError as e:
-        # 1. 获取报错字段的路径 (例如: "user.phone")
-        field = ".".join(map(str, e.path)) if e.path else "root"
-        
-        # 2. 优先尝试从 Schema 定义中获取人类可读的 'description' 或 'title'
-        # e.schema 是当前校验失败的那个具体字段的 schema 定义片段
-        custom_msg = e.schema.get("description") or e.schema.get("title")
-        
-        # 3. 构建错误信息
-        if e.validator == 'pattern':
-            # 如果是正则错误 (pattern),且我们定义了 description,就用 description
-            # 如果没定义,就给一个通用的 "格式不正确"
-            reason = custom_msg if custom_msg else "format is invalid"
-        else:
-            # 其他类型的错误(如类型不对、必填项缺失),保留原报错或也尝试用 description
-            reason = custom_msg if custom_msg else e.message
+        path_prefix = ".".join(map(str, e.path))
+
+        # 1. 必填字段缺失错误 (required)
+        if e.validator == 'required':
+            match = re.search(r"'([^']+)' is a required property", e.message)
+            missing_prop = match.group(1) if match else (e.validator_value[0] if isinstance(e.validator_value, list) and e.validator_value else "unknown")
+            field = f"{path_prefix}.{missing_prop}" if path_prefix else missing_prop
+
+            # 尝试从 properties 中获取该字段的人类可读名称 (title)
+            prop_schema = e.schema.get("properties", {}).get(missing_prop, {}) if isinstance(e.schema, dict) else {}
+            field_name = prop_schema.get("title") or missing_prop
+            raise BizLogicError(f"Missing required field [{field}]: '{field_name}' is required")
 
-        # 4. 抛出最终的人话提示
-        raise BizLogicError(f"Invalid parameter [{field}]: {reason}")
+        # 2. 正则格式错误 (pattern)
+        elif e.validator == 'pattern':
+            field = path_prefix or "root"
+            prop_title = e.schema.get("title") or field if isinstance(e.schema, dict) else field
+            desc = e.schema.get("description") if isinstance(e.schema, dict) else None
+            detail = f" ({desc})" if desc else f" ({e.message})"
+            raise BizLogicError(f"Invalid parameter [{field}]: '{prop_title}' format is invalid{detail}")
+
+        # 3. 字段类型错误 (type)
+        elif e.validator == 'type':
+            field = path_prefix or "root"
+            prop_title = e.schema.get("title") or field if isinstance(e.schema, dict) else field
+            raise BizLogicError(f"Invalid parameter [{field}]: '{prop_title}' must be of type '{e.validator_value}'")
+
+        # 4. 未知扩展字段错误 (additionalProperties)
+        elif e.validator == 'additionalProperties':
+            field = path_prefix or "root"
+            raise BizLogicError(f"Invalid parameter [{field}]: {e.message}")
+
+        # 5. 其他类型验证错误 (enum, minimum, maximum, etc.)
+        else:
+            field = path_prefix or "root"
+            prop_title = e.schema.get("title") if isinstance(e.schema, dict) else None
+            prefix = f"'{prop_title}': " if (prop_title and field != "root") else ""
+            raise BizLogicError(f"Invalid parameter [{field}]: {prefix}{e.message}")

+ 121 - 0
tests/test_admin_order_payment.py

@@ -0,0 +1,121 @@
+import unittest
+from unittest.mock import AsyncMock, MagicMock, patch
+from datetime import datetime
+
+from app.models.order import VasOrder
+from app.models.payment import VasPayment
+from app.models.product import VasProduct
+from app.models.user import VasUser
+from app.schemas.order import VasOrderCreateAdmin, VasOrderRegisterPayment
+from app.services.order_service import OrderService
+
+
+class TestAdminOrderPayment(unittest.IsolatedAsyncioTestCase):
+
+    def setUp(self):
+        self.admin = VasUser(id="admin_1", email="admin@example.com", role="admin")
+        self.product = VasProduct(
+            id=10,
+            country="FR",
+            city="PAR",
+            visa_type="tourist",
+            provider="tls",
+            title="法国旅游签证抢号服务",
+            price_amount=50000,
+            price_currency="CNY",
+            min_floor_price=30000,
+        )
+
+    @patch("app.services.webhook_service.WebhookService._create_task_if_not_exists", new_callable=AsyncMock)
+    async def test_create_by_admin_pay_later(self, mock_create_task):
+        db = AsyncMock()
+        payload = VasOrderCreateAdmin(
+            product_id=10,
+            user_inputs={"applicant_name": "张三"},
+            channel_type="direct",
+            handler_id="admin_1",
+            final_amount=45000,
+            payment_timing="pay_later",
+        )
+
+        order = await OrderService.create_by_admin(db, payload, self.product, self.admin)
+
+        self.assertEqual(order.status, "pending")
+        self.assertEqual(order.final_amount, 45000)
+        self.assertEqual(order.adjustment_delta, -5000)
+        self.assertEqual(order.user_inputs["_admin_bypass"]["payment_timing"], "pay_later")
+        mock_create_task.assert_awaited_once_with(db, order)
+        db.add.assert_called_once_with(order)
+
+    @patch("app.services.webhook_service.WebhookService._create_task_if_not_exists", new_callable=AsyncMock)
+    async def test_create_by_admin_paid_now(self, mock_create_task):
+        db = AsyncMock()
+        payload = VasOrderCreateAdmin(
+            product_id=10,
+            user_inputs={"applicant_name": "李四"},
+            channel_type="direct",
+            handler_id="admin_1",
+            final_amount=50000,
+            payment_timing="paid_now",
+            payment_method="wechat",
+            external_trade_no="WX123456789",
+            payment_note="现场微信全款付清",
+        )
+
+        order = await OrderService.create_by_admin(db, payload, self.product, self.admin)
+
+        self.assertEqual(order.status, "paid")
+        self.assertEqual(order.final_amount, 50000)
+        # 验证写入了 order 和 payment
+        added_objs = [call.args[0] for call in db.add.call_args_list]
+        payments = [o for o in added_objs if isinstance(o, VasPayment)]
+        self.assertEqual(len(payments), 1)
+        self.assertEqual(payments[0].status, "succeeded")
+        self.assertEqual(payments[0].provider, "wechat")
+        self.assertEqual(payments[0].amount, 50000)
+        self.assertEqual(payments[0].external_trade_no, "WX123456789")
+
+    async def test_register_payment_success(self):
+        db = AsyncMock()
+        existing_order = VasOrder(
+            id="ORD-2026-TEST-999",
+            user_id="user_1",
+            product_id=10,
+            base_amount=50000,
+            final_amount=50000,
+            adjustment_delta=0,
+            base_currency="CNY",
+            status="pending",
+            channel_type="direct",
+            settlement_status="unsettled",
+            user_inputs={"_admin_bypass": {"payment_timing": "pay_later"}},
+        )
+
+        mock_res = MagicMock()
+        mock_res.scalar_one_or_none.return_value = existing_order
+        db.execute.return_value = mock_res
+
+        payload = VasOrderRegisterPayment(
+            order_id="ORD-2026-TEST-999",
+            amount=48000,
+            payment_method="alipay",
+            external_trade_no="ALI998877",
+            note="办妥出签后支付宝结清尾款",
+        )
+
+        updated_order = await OrderService.register_payment(db, payload, self.admin)
+
+        self.assertEqual(updated_order.status, "paid")
+        self.assertEqual(updated_order.final_amount, 48000)
+        self.assertEqual(updated_order.adjustment_delta, -2000)
+        self.assertEqual(len(updated_order.user_inputs["_payments_history"]), 1)
+        self.assertEqual(updated_order.user_inputs["_payments_history"][0]["amount"], 48000)
+        self.assertEqual(updated_order.user_inputs["_payments_history"][0]["provider"], "alipay")
+
+        # 检查是否新增了 VasPayment
+        added_payment = db.add.call_args[0][0]
+        self.assertIsInstance(added_payment, VasPayment)
+        self.assertEqual(added_payment.status, "succeeded")
+        self.assertEqual(added_payment.amount, 48000)
+        self.assertEqual(added_payment.provider, "alipay")
+        self.assertEqual(added_payment.external_trade_no, "ALI998877")