Selaa lähdekoodia

refactor: modularize api router, clean unused services, enhance logging & fix configs

jerry 2 kuukautta sitten
vanhempi
sitoutus
f395419b74
39 muutettua tiedostoa jossa 2874 lisäystä ja 2502 poistoa
  1. 1 0
      app/api/endpoints/__init__.py
  2. 60 0
      app/api/endpoints/account.py
  3. 99 0
      app/api/endpoints/auth.py
  4. 96 0
      app/api/endpoints/common.py
  5. 74 0
      app/api/endpoints/config.py
  6. 204 0
      app/api/endpoints/email.py
  7. 134 0
      app/api/endpoints/notification.py
  8. 141 0
      app/api/endpoints/order.py
  9. 173 0
      app/api/endpoints/payment.py
  10. 143 0
      app/api/endpoints/product.py
  11. 60 0
      app/api/endpoints/proxy.py
  12. 74 0
      app/api/endpoints/slot.py
  13. 55 0
      app/api/endpoints/sms.py
  14. 54 0
      app/api/endpoints/task.py
  15. 101 0
      app/api/endpoints/ticket.py
  16. 54 0
      app/api/endpoints/user.py
  17. 99 0
      app/api/endpoints/vas_task.py
  18. 58 0
      app/api/endpoints/webhook.py
  19. 50 1397
      app/api/router.py
  20. 18 1
      app/core/config.py
  21. 55 18
      app/core/logger.py
  22. 46 2
      app/main.py
  23. 1 0
      app/schemas/llm.py
  24. 19 0
      app/services/auth_service.py
  25. 11 94
      app/services/emails_service.py
  26. 0 150
      app/services/fake_service.py
  27. 136 65
      app/services/llm_service.py
  28. 12 2
      app/services/order_service.py
  29. 6 1
      app/services/payment_service.py
  30. 0 63
      app/services/scheduler_handlers.py
  31. 0 97
      app/services/scheduler_service.py
  32. 174 125
      app/services/seaweedfs_service.py
  33. 139 156
      app/services/task_handlers.py
  34. 80 95
      app/services/vas_task_service.py
  35. 0 108
      app/services/visametric_service.py
  36. 21 9
      app/services/webhook_service.py
  37. 12 4
      docker-compose.yml
  38. 2 1
      requirements.txt
  39. 412 114
      scripts/notification_templates.py

+ 1 - 0
app/api/endpoints/__init__.py

@@ -0,0 +1 @@
+# API Endpoints package

+ 60 - 0
app/api/endpoints/account.py

@@ -0,0 +1,60 @@
+from fastapi import APIRouter, Query, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.utils.response import success
+from app.schemas.account import AccountCreate, AccountOut, AccountUpdate, GetNextAccountPayload
+from app.schemas.common import ApiResponse, PageResponse
+from app.services.account_service import AccountService
+
+public_router = APIRouter()
+protected_router = APIRouter()
+admin_required_router = APIRouter()
+
+
+@admin_required_router.get("/account/list_all", summary="分页查询账号", tags=["账号管理"], response_model=ApiResponse[PageResponse[AccountOut]])
+async def account_list(
+    page: int = Query(0, description="第几页"),
+    size: int = Query(10, description="分页大小"),
+    keyword: str = Query("", description="查询条件"),
+    db: AsyncSession = Depends(get_db)
+):
+    obj = await AccountService.list_all(db, page, size, keyword)
+    return success(data=obj)
+
+
+@admin_required_router.post("/account/next", summary="获取下一个账号", tags=["账号管理"], response_model=ApiResponse[AccountOut])
+async def account_next(
+    payload: GetNextAccountPayload, 
+    db: AsyncSession = Depends(get_db)
+):
+    account = await AccountService.get_next_account(db, payload.pool_name, payload.account_cd)
+    return success(data=account)
+
+
+@admin_required_router.post("/account/add", summary="新增一个账号", tags=["账号管理"], response_model=ApiResponse[AccountOut])
+async def account_add(
+    payload: AccountCreate,
+    db: AsyncSession = Depends(get_db)
+):
+    account = await AccountService.add_account(db, payload)
+    return success(data=account)
+
+
+@admin_required_router.delete("/account/delete", summary="删除账号", tags=["账号管理"], response_model=ApiResponse)
+async def account_remove(
+    account_id: int,
+    db: AsyncSession = Depends(get_db)
+):
+    await AccountService.remove_account(db, account_id)
+    return success()
+
+
+@admin_required_router.put("/account/update", summary="更新账号", tags=["账号管理"], response_model=ApiResponse[AccountOut])
+async def account_update(
+    account_id: int,
+    payload: AccountUpdate,
+    db: AsyncSession = Depends(get_db)
+):
+    account = await AccountService.update_account(db, account_id, payload)
+    return success(data=account)
+

+ 99 - 0
app/api/endpoints/auth.py

@@ -0,0 +1,99 @@
+from fastapi import APIRouter, Request, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.redis import get_redis_client
+from app.core.database import get_db
+from app.core.auth import get_current_user
+from redis.asyncio import Redis
+from app.utils.response import success
+from app.models.user import VasUser
+from app.schemas.auth import AutoRegisterData, AutoRegisterRequest, BindEmailRequest, LoginData, LoginRequest, ResetPasswordRequest, SendBindCodeRequest, SendResetCodeRequest
+from app.schemas.common import ApiResponse
+from app.services.auth_service import AuthService
+
+public_router = APIRouter()
+protected_router = APIRouter()
+admin_required_router = APIRouter()
+
+
+@public_router.post("/auth/auto-register", summary="自动注册", tags=["用户管理"], response_model=ApiResponse[AutoRegisterData])
+async def vas_auto_register(
+    payload: AutoRegisterRequest,
+    request: Request,
+    db: AsyncSession = Depends(get_db)
+):
+    user_agent = request.headers.get("user-agent", "unknown")
+    client_host = request.client.host
+    x_forwarded_for = request.headers.get("x-forwarded-for")
+    if x_forwarded_for:
+        client_ip = x_forwarded_for.split(",")[0].strip()
+    else:
+        client_ip = client_host
+    res = await AuthService.auto_register(db, payload, client_ip, user_agent)
+    return success(data=res)
+
+
+@public_router.post("/auth/send-bind-code", summary="发送邮箱注册码 绑定邮箱用", tags=["用户管理"], response_model=ApiResponse)
+async def vas_send_bind_code(
+    payload: SendBindCodeRequest,
+    current_user: VasUser = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+    redis_client: Redis = Depends(get_redis_client)
+):
+    await AuthService.send_bind_code(db, payload, current_user, redis_client)
+    return success(message="verify email sent, please check your inbox")
+
+
+@public_router.post("/auth/send-reset-code", summary="发送邮箱注册码 重置密码用", tags=["用户管理"], response_model=ApiResponse)
+async def vas_send_reset_code(
+    payload: SendResetCodeRequest,
+    db: AsyncSession = Depends(get_db),
+    redis_client: Redis = Depends(get_redis_client)
+):
+    await AuthService.send_reset_code(db, payload, redis_client)
+    return success(message="verify email sent, please check your inbox")
+
+
+@protected_router.post("/auth/bind-email", summary="绑定邮箱", tags=["用户管理"], response_model=ApiResponse[LoginData])
+async def vas_bind_email(
+    payload: BindEmailRequest,
+    request: Request,
+    current_user: VasUser = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+    redis_client: Redis = Depends(get_redis_client)
+):
+    user_agent = request.headers.get("user-agent", "unknown")
+    client_host = request.client.host
+    x_forwarded_for = request.headers.get("x-forwarded-for")
+    if x_forwarded_for:
+        client_ip = x_forwarded_for.split(",")[0].strip()
+    else:
+        client_ip = client_host
+    res = await AuthService.bind_email(db, payload, current_user, redis_client, client_ip, user_agent)
+    return success(data=res)
+
+
+@public_router.post("/auth/reset-password", summary="重置密码", tags=["用户管理"], response_model=ApiResponse)
+async def vas_reset_password(
+    payload: ResetPasswordRequest,
+    db: AsyncSession = Depends(get_db)
+):
+    res = await AuthService.reset_password(db, payload)
+    return success(data=res)
+
+
+@public_router.post("/auth/login", summary="邮箱登录", tags=["用户管理"], response_model=ApiResponse[LoginData])
+async def vas_login(
+    payload: LoginRequest,
+    request: Request,
+    db: AsyncSession = Depends(get_db)
+):
+    user_agent = request.headers.get("user-agent", "unknown")
+    client_host = request.client.host
+    x_forwarded_for = request.headers.get("x-forwarded-for")
+    if x_forwarded_for:
+        client_ip = x_forwarded_for.split(",")[0].strip()
+    else:
+        client_ip = client_host
+    res = await AuthService.login(db, payload, client_ip, user_agent)
+    return success(data=res)
+

+ 96 - 0
app/api/endpoints/common.py

@@ -0,0 +1,96 @@
+from app.core.logger import logger
+from fastapi import APIRouter, Response, Query, Depends, UploadFile, File
+from fastapi.responses import RedirectResponse
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.utils.response import success
+from app.schemas.common import ApiResponse
+from app.schemas.http_session import HttpSessionCreate, HttpSessionOut
+from app.schemas.llm import ParseUserInputsOut, ParseUserInputsPayload
+from app.schemas.resource import FileUploadOut
+from app.schemas.short_url import ShortUrlCreate, ShortUrlOut
+from app.schemas.statistics import VasStatisticsOverviewOut
+from app.services.http_session_service import HttpSessionService
+from app.services.llm_service import LlmService
+from app.services.seaweedfs_service import SeaweedFSService
+from app.services.short_url_service import ShortUrlService
+from app.services.statistics_service import StatisticsService
+
+public_router = APIRouter()
+protected_router = APIRouter()
+admin_required_router = APIRouter()
+
+
+@admin_required_router.get("/ping", summary="心跳检测", tags=["测试接口"])
+async def ping():
+    return {"message": "pong"}
+
+
+@admin_required_router.post("/http-session", summary="创建http session", tags=["会话管理"], response_model=ApiResponse[HttpSessionOut])
+async def http_session_create(
+    data: HttpSessionCreate,
+    db: AsyncSession = Depends(get_db)
+):
+    logger.info(f"[Create HttpSession] sid={data.session_id}")
+    obj = await HttpSessionService.create(db, data)
+    return success(data=obj)
+
+
+@admin_required_router.get("/http-session", summary="读取http session", tags=["会话管理"], response_model=ApiResponse[HttpSessionOut])
+async def http_session_get_by_sid(
+    session_id: str = Query(...),
+    db: AsyncSession = Depends(get_db)
+):
+    logger.info(f"[Get HttpSession] sid={session_id}")
+    obj = await HttpSessionService.get_by_sid(db, session_id)
+    return success(data=obj)
+
+
+@public_router.post("/resource/upload_file", summary="上传文件", tags=["文件管理"], response_model=ApiResponse[FileUploadOut])
+async def resource_upload_file(file: UploadFile = File(...)):
+    result = await SeaweedFSService.upload(file)
+    return success(data=result)
+
+
+@public_router.get("/resource/download_file", summary="下载文件", tags=["文件管理"])
+async def resource_get_file(fid: str):
+    data = await SeaweedFSService.get(fid)
+    if not data:
+        return Response(content=b"File not found", status_code=404, media_type="text/plain")
+    content, mime = data
+    return Response(content=content, media_type=mime)
+
+
+
+@admin_required_router.post("/s/generate", summary="生成短链接地址<压缩地址长度>", tags=["Short URL"], response_model=ApiResponse[ShortUrlOut])
+async def short_url_generate(
+    data: ShortUrlCreate,
+    db: AsyncSession = Depends(get_db),
+):
+    """生成短链接"""
+    record = await ShortUrlService.create_short_url(db, data.long_url)
+    return success(data=record)
+
+
+@public_router.get("/s/{short_key}", summary="访问短链接地址<自动重定向到真实链接地址>", tags=["Short URL"])
+async def short_url_request(short_key: str, db: AsyncSession = Depends(get_db)):
+    """访问短链接自动重定向"""
+    long_url = await ShortUrlService.get_long_url(db, short_key)
+    return RedirectResponse(url=long_url, status_code=302)
+
+
+@admin_required_router.get("/vas/statistics/overview", summary="系统概览", tags=["textskin"], response_model=ApiResponse[VasStatisticsOverviewOut])
+async def vas_statistics_overview(
+    db: AsyncSession = Depends(get_db)
+):
+    overview = await StatisticsService.overview(db)
+    return success(data=overview)
+
+
+@admin_required_router.post("/vas/llm/data_parsing", summary="llm数据解析", tags=["textskin"], response_model=ApiResponse[ParseUserInputsOut])
+async def vas_llm_data_parsing(
+    payload: ParseUserInputsPayload,
+    db: AsyncSession = Depends(get_db)
+):
+    out = await LlmService.handle_parse(db, payload)
+    return success(data=out)

+ 74 - 0
app/api/endpoints/config.py

@@ -0,0 +1,74 @@
+from typing import List, Dict, Any, Optional
+from fastapi import APIRouter, Query, Depends, Body
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.utils.response import success
+from app.schemas.common import ApiResponse
+from app.schemas.configuration import ConfigurationCreate, ConfigurationOut, ConfigurationUpdate
+from app.schemas.visa_free_config import VisaFreeConfigFetchRequest
+from app.services.configuration_service import ConfigurationService
+from app.services.visa_free_config_service import fetch_visa_free_config
+
+public_router = APIRouter()
+protected_router = APIRouter()
+admin_required_router = APIRouter()
+
+
+@admin_required_router.post("/dynamic-configurations", summary="创建动态配置", tags=["动态配置"], response_model=ApiResponse[ConfigurationOut])
+async def dynamic_config_create(config_in: ConfigurationCreate, db: AsyncSession = Depends(get_db)):
+    obj = await ConfigurationService.create(db, config_in)
+    return success(data=obj)
+
+
+@admin_required_router.get("/dynamic-configurations/all", summary="读取所有动态配置", tags=["动态配置"], response_model=ApiResponse[List[ConfigurationOut]])
+async def dynamic_config_get_all(db: AsyncSession = Depends(get_db)):
+    obj = await ConfigurationService.get_all(db)
+    return success(data=obj)
+
+
+@admin_required_router.get("/dynamic-configurations/key/{config_key}", summary="根据Key读取动态配置", tags=["动态配置"], response_model=ApiResponse[ConfigurationOut])
+async def dynamic_config_get_by_key(config_key: str, db: AsyncSession = Depends(get_db)):
+    config = await ConfigurationService.get_by_key(db, config_key)
+    return success(data=config)
+
+
+@admin_required_router.put("/dynamic-configurations/key/{config_key}", summary="根据Key更新动态配置", tags=["动态配置"], response_model=ApiResponse[ConfigurationOut])
+async def dynamic_config_update_by_key(config_key: str, config_in: ConfigurationUpdate, db: AsyncSession = Depends(get_db)):
+    config = await ConfigurationService.update_by_key(db, config_key, config_in)
+    return success(data=config)
+
+
+@admin_required_router.delete("/dynamic-configurations/key/{config_key}", summary="根据Key删除动态配置", tags=["动态配置"], response_model=ApiResponse[ConfigurationOut])
+async def dynamic_config_delete_by_key(config_key: str, db: AsyncSession = Depends(get_db)):
+    config = await ConfigurationService.delete_by_key(db, config_key)
+    return success(data=config)
+
+
+@protected_router.post("/visa/free-config/fetch", summary="获取签证中心 free_config 配置", tags=["Visa Config"], response_model=ApiResponse[Dict[str, Any]])
+async def fetch_visa_free_config_post(payload: VisaFreeConfigFetchRequest = Body(...)):
+    res = fetch_visa_free_config(
+        provider=payload.provider,
+        origin=payload.origin,
+        target=payload.target,
+        visa_type=payload.visa_type,
+        vac=payload.vac
+    )
+    return success(data=res)
+
+
+@protected_router.get("/visa/free-config/fetch", summary="获取签证中心 free_config 配置(GET)", tags=["Visa Config"], response_model=ApiResponse[Dict[str, Any]])
+async def fetch_visa_free_config_get(
+    provider: str = Query(...),
+    origin: str = Query(...),
+    target: str = Query(...),
+    visa_type: str = Query(...),
+    vac: Optional[str] = Query(None)
+):
+    res = fetch_visa_free_config(
+        provider=provider,
+        origin=origin,
+        target=target,
+        visa_type=visa_type,
+        vac=vac
+    )
+    return success(data=res)

+ 204 - 0
app/api/endpoints/email.py

@@ -0,0 +1,204 @@
+from typing import List
+from fastapi import APIRouter, Query, Depends, Body
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.utils.response import success
+from app.schemas.common import ApiResponse
+from app.schemas.email_authorizations import EmailAuthorizationCreate, EmailAuthorizationOut, EmailAuthorizationUpdate, EmailContent
+from app.schemas.emails import VasEmailCreate, VasEmailOut
+from app.services.email_authorizations_service import EmailAuthorizationService
+from app.services.emails_service import EmailsService
+
+public_router = APIRouter()
+protected_router = APIRouter()
+admin_required_router = APIRouter()
+
+
+@admin_required_router.get("/email-authorizations", summary="查询所有内部邮箱", tags=["邮箱接口"], response_model=ApiResponse[List[EmailAuthorizationOut]])
+async def email_authorizations_get(db: AsyncSession = Depends(get_db)):
+    obj = await EmailAuthorizationService.get_all(db)
+    return success(data=obj)
+
+
+@admin_required_router.post("/email-authorizations", summary="创建内部邮箱", tags=["邮箱接口"], response_model=ApiResponse[EmailAuthorizationOut])
+async def email_authorizations_create(data: EmailAuthorizationCreate, db: AsyncSession = Depends(get_db)):
+    obj = await EmailAuthorizationService.create(db, data)
+    return success(data=obj)
+
+
+@admin_required_router.get("/email-authorizations/{id}", summary="通过id查询内部邮箱", tags=["邮箱接口"], response_model=ApiResponse[EmailAuthorizationOut])
+async def email_authorizations_get_by_id(id: int, db: AsyncSession = Depends(get_db)):
+    email_auth = await EmailAuthorizationService.get_by_id(db, id)
+    return success(data=email_auth)
+
+
+@admin_required_router.put("/email-authorizations/{id}", summary="通过id更新内部邮箱", tags=["邮箱接口"], response_model=ApiResponse[EmailAuthorizationOut])
+async def email_authorizations_update_by_id(id: int, data: EmailAuthorizationUpdate, db: AsyncSession = Depends(get_db)):
+    updated = await EmailAuthorizationService.update(db, id, data)
+    return success(data=updated)
+
+
+@admin_required_router.delete("/email-authorizations/{id}", summary="通过id删除内部邮箱", tags=["邮箱接口"], response_model=ApiResponse[EmailAuthorizationOut])
+async def email_authorizations_delete_by_id(id: int, db: AsyncSession = Depends(get_db)):
+    deleted = await EmailAuthorizationService.delete(db, id)
+    return success(data=deleted)
+
+
+@admin_required_router.get("/email-authorizations/email/{email}", summary="通过邮箱地址查询内部邮箱", tags=["邮箱接口"], response_model=ApiResponse[EmailAuthorizationOut])
+async def email_authorizations_get_by_email(email: str, db: AsyncSession = Depends(get_db)):
+    email_auth = await EmailAuthorizationService.get_by_email(db, email)
+    return success(data=email_auth)
+
+
+@admin_required_router.post("/email-authorizations/fetch", summary="读取邮件, 仅限文本内容", tags=["邮箱接口"], response_model=ApiResponse[EmailContent])
+async def email_authorizations_fetch_email(
+    email: str = Query(..., description="收件邮箱账号, 格式: xxx@xxx.xxx"),
+    sender: str = Query(..., description="发件人邮箱账号或者名字"),
+    recipient: str = Query(..., description="收件人账号或者名字"),
+    subjectKeywords: str = Query("", description="邮件主题关键词, 支持多个关键词, 用逗号隔开"),
+    bodyKeywords: str = Query("", description="邮件内容关键词, 支持多个关键词, 用逗号隔开"),
+    sentDate: str = Query(..., description="发件日期, UTC时间, 格式: yyyy-mm-dd hh:mm:ss"),
+    expiry: int = Query(300, description="邮件有效期, 单位秒, 从sentDate 开始算起"),
+    onlyText: bool = Query(True, description="是否纯文本"),
+    db: AsyncSession = Depends(get_db)
+):
+    auth = await EmailAuthorizationService.get_by_email(db, email)
+    print(auth)
+    result = await EmailAuthorizationService.fetch_email_authorizations(
+        auth,
+        sender=sender,
+        recipient=recipient,
+        subject_keywords=subjectKeywords,
+        body_keywords=bodyKeywords,
+        sent_date=sentDate,
+        expiry=expiry,
+        only_text=onlyText
+    )
+    return success(data={"body": result})
+
+
+@admin_required_router.post("/email-authorizations/fetch-top", summary="从最近的几封邮件读取目标邮件,仅限文本内容, 性能会更好, 邮件多时有可能漏读", tags=["邮箱接口"], response_model=ApiResponse[EmailContent])
+async def email_authorizations_fetch_email_from_topn(
+    email: str = Query(..., description="收件邮箱账号, 格式: xxx@xxx.xxx"),
+    sender: str = Query(..., description="发件人邮箱账号或者名字"),
+    recipient: str = Query(..., description="收件人账号或者名字"),
+    subjectKeywords: str = Query("", description="邮件主题关键词, 支持多个关键词, 用逗号隔开"),
+    bodyKeywords: str = Query("", description="邮件内容关键词, 支持多个关键词, 用逗号隔开"),
+    top: int = Query(10, description="指定从最近几封邮件读取"),
+    onlyText: bool = Query(True, description="是否纯文本"),
+    db: AsyncSession = Depends(get_db)
+):
+    auth = await EmailAuthorizationService.get_by_email(db, email)
+    result = await EmailAuthorizationService.fetch_email_authorizations_from_top_n(
+        auth,
+        sender=sender,
+        recipient=recipient,
+        subject_keywords=subjectKeywords,
+        body_keywords=bodyKeywords,
+        top=top,
+        only_text=onlyText
+    )
+    return success(data={"body": result})
+
+
+@admin_required_router.post("/email-authorizations/forward", summary="转发邮件", tags=["邮箱接口"], response_model=ApiResponse[EmailContent])
+async def email_authorizations_forward_email(
+    emailAccount: str = Query(..., description="收件邮箱账号, 格式: xxx@xxx.xxx"),
+    forwardTo: str = Query(..., description="转发到哪个邮箱地址, 格式: xxx@xxx.xxx"),
+    sender: str = Query(..., description="发件人邮箱账号或者名字"),
+    recipient: str = Query(..., description="收件人账号或者名字"),
+    subjectKeywords: str = Query("", description="邮件主题关键词, 支持多个关键词, 用逗号隔开"),
+    bodyKeywords: str = Query("", description="邮件内容关键词, 支持多个关键词, 用逗号隔开"),
+    db: AsyncSession = Depends(get_db)
+):
+    auth = await EmailAuthorizationService.get_by_email(db, emailAccount)
+    result = await EmailAuthorizationService.forward_first_matching_email(
+        auth,
+        forward_to = forwardTo,
+        sender = sender,
+        recipient = recipient,
+        subject_keywords = subjectKeywords,
+        body_keywords = bodyKeywords
+    )
+    return success(data={"body": result})
+
+
+@admin_required_router.post("/email-authorizations/forward2", summary="转发邮件(新)", tags=["邮箱接口"], response_model=ApiResponse[EmailContent])
+async def email_authorizations_forward_email2(
+    emailAccount: str = Query(..., description="收件邮箱账号, 格式: xxx@xxx.xxx"),
+    forwardTo: str = Query(..., description="转发到哪个邮箱地址, 格式: xxx@xxx.xxx"),
+    sender: str = Query(..., description="发件人邮箱账号或者名字"),
+    recipient: str = Query(..., description="收件人账号或者名字"),
+    subjectKeywords: str = Query("", description="邮件主题关键词, 支持多个关键词, 用逗号隔开"),
+    bodyKeywords: str = Query("", description="邮件内容关键词, 支持多个关键词, 用逗号隔开"),
+    db: AsyncSession = Depends(get_db)
+):
+    auth = await EmailAuthorizationService.get_by_email(db, emailAccount)
+    result = await EmailAuthorizationService.forward_first_matching_email2(
+        db,
+        auth,
+        forward_to = forwardTo,
+        sender = sender,
+        recipient = recipient,
+        subject_keywords = subjectKeywords,
+        body_keywords = bodyKeywords
+    )
+    return success(data={"body": result})
+
+
+@admin_required_router.post("/email-authorizations/sendmail", summary="发送邮件", tags=["邮箱接口"], response_model=ApiResponse[EmailContent])
+async def email_authorizations_send_email(
+    emailAccount: str = Query(..., description="发件账号, 格式: xxx@xxx.xxx"),
+    sendTo: str = Query(..., description="收件人邮箱账号"),
+    subject: str = Query(..., description="邮件主题"),
+    contentType: str = Query("text", description="内容格式,支持 text 和 html"),
+    content: EmailContent = Body("", description="邮件内容"),
+    db: AsyncSession = Depends(get_db)
+):
+    auth = await EmailAuthorizationService.get_by_email(db, emailAccount)
+    result = await EmailAuthorizationService.send_email(
+        auth,
+        send_to = sendTo,
+        subject = subject,
+        content_type = contentType,
+        content = content.body
+    )
+    return success(data={"body": result})
+
+
+@admin_required_router.post("/email-authorizations/sendmail-bulk", summary="群发送邮件", tags=["邮箱接口"], response_model=ApiResponse[EmailContent])
+async def email_authorizations_send_email_bulk(
+    emailAccount: str = Query(..., description="收件邮箱账号, 格式: xxx@xxx.xxx"),
+    sendTo: str = Query(..., description="收件人邮箱账号,多个用逗号隔开"),
+    subject: str = Query(..., description="邮件主题"),
+    contentType: str = Query("text", description="内容格式,支持 text 和 html"),
+    content: EmailContent = Body(..., description="邮件内容"),
+    db: AsyncSession = Depends(get_db)
+):
+    auth = await EmailAuthorizationService.get_by_email(db, emailAccount)
+    result = await EmailAuthorizationService.send_email_bulk(
+        auth,
+        send_to = sendTo,
+        subject = subject,
+        content_type = contentType,
+        content = content.body
+    )
+    return success(data={"body": result})
+
+
+@admin_required_router.post("/emails/write", summary="写入邮件", tags=["邮箱接口"], response_model=ApiResponse[VasEmailOut])
+async def emails_write(
+    payload: VasEmailCreate,
+    db: AsyncSession = Depends(get_db)
+):
+    rec = await EmailsService.create(db, payload)
+    return success(data=rec)
+
+
+@admin_required_router.get("/emails/max_uid", summary="获取最大邮件UID", tags=["邮箱接口"], response_model=ApiResponse[int])
+async def emails_get_max_uid(
+    db: AsyncSession = Depends(get_db)
+):
+    uid = await EmailsService.get_max_uid(db)
+    return success(data=uid)
+

+ 134 - 0
app/api/endpoints/notification.py

@@ -0,0 +1,134 @@
+from fastapi import APIRouter, Query, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.utils.response import success
+from app.schemas.common import ApiResponse, PageResponse
+from app.schemas.notification_outbox import NotificationOutboxCreate, NotificationOutboxOut, NotificationOutboxUpdate
+from app.schemas.telegram import TelegramIn, TelegramNoTokenIn
+from app.schemas.wechat import WechatIn, WechatNoTokenIn
+from app.schemas.whatsapp import WhatsappIn, WhatsappNoTokenIn
+from app.services.notification_outbox_service import NotificationOutboxService
+from app.services.telegram_service import TelegramService
+from app.services.wechat_service import WechatService
+from app.services.whatsapp_service import WhatsappService
+
+public_router = APIRouter()
+protected_router = APIRouter()
+admin_required_router = APIRouter()
+
+
+@admin_required_router.post("/tg/send_message", summary="推送电报消息", tags=["消息推送接口"], response_model=ApiResponse)
+async def tg_send_message(
+    payload: TelegramIn
+):
+    await TelegramService.push_text(payload)
+    return success()
+
+
+@admin_required_router.post("/tg/send_message_no_token", summary="推送电报消息(无需token)", tags=["消息推送接口"], response_model=ApiResponse)
+async def tg_send_message_no_token(
+    payload: TelegramNoTokenIn
+):
+    await TelegramService.push_text_no_token(payload)
+    return success()
+
+
+@admin_required_router.post("/wechat/send", summary="推送微信文本消息", tags=["消息推送接口"], response_model=ApiResponse)
+async def wechat_send(
+    payload: WechatIn
+):
+    await WechatService.push_text(payload.api_token, payload.message)
+    return success()
+
+
+@admin_required_router.post("/wechat/send_no_token", summary="推送微信文本消息(无需token)", tags=["消息推送接口"], response_model=ApiResponse)
+async def wechat_send_no_token(
+    payload: WechatNoTokenIn
+):
+    await WechatService.push_text_no_token(payload.message)
+    return success()
+
+
+@admin_required_router.post("/wechat/send_markdown_no_token", summary="推送微信Markdown消息(无需token)", tags=["消息推送接口"], response_model=ApiResponse)
+async def wechat_send_markdown_no_token(
+    payload: WechatNoTokenIn
+):
+    await WechatService.push_markdown_no_token(payload.message)
+    return success()
+
+
+@admin_required_router.post("/wechat/send_markdown", summary="推送微信Markdown消息", tags=["消息推送接口"], response_model=ApiResponse)
+async def wechat_send_markdown(
+    payload: WechatIn
+):
+    await WechatService.push_markdown(payload.api_token, payload.message)
+    return success()
+
+
+@admin_required_router.post("/whatsapp/send", summary="推送WhatsApp消息", tags=["消息推送接口"], response_model=ApiResponse)
+async def whatsapp_send(
+    payload: WhatsappIn
+):
+    api_base_url = payload.api_base_url or "https://waha.text.skin"
+    await WhatsappService.send_text(
+        api_base_url=api_base_url,
+        session=payload.session,
+        chat_id=payload.chat_id,
+        message=payload.message,
+        api_key=payload.api_key,
+    )
+    return success()
+
+
+@admin_required_router.post("/whatsapp/send_no_token", summary="推送WhatsApp消息(无需token)", tags=["消息推送接口"], response_model=ApiResponse)
+async def whatsapp_send_no_token(
+    payload: WhatsappNoTokenIn
+):
+    await WhatsappService.send_text_no_token(
+        chat_id=payload.chat_id,
+        message=payload.message,
+    )
+    return success()
+
+
+@admin_required_router.post("/notification/outbox/create", summary="创建通知消息", tags=["消息推送接口"], response_model=ApiResponse[NotificationOutboxOut])
+async def notification_outbox_create(
+    payload: NotificationOutboxCreate,
+    db: AsyncSession = Depends(get_db)
+):
+    obj = await NotificationOutboxService.create(db, payload)
+    return success(data=obj)
+
+
+@admin_required_router.post("/notification/outbox/update", summary="更新通知消息", tags=["消息推送接口"], response_model=ApiResponse[NotificationOutboxOut])
+async def notification_outbox_update(
+    id: int,
+    payload: NotificationOutboxUpdate,
+    db: AsyncSession = Depends(get_db)
+):
+    obj = await NotificationOutboxService.update(db, id, payload)
+    return success(data=obj)
+
+
+@admin_required_router.get("/notification/outbox/detail", summary="获取通知详情", tags=["消息推送接口"], response_model=ApiResponse[NotificationOutboxOut])
+async def notification_outbox_detail(
+    id: int,
+    db: AsyncSession = Depends(get_db)
+):
+    obj = await NotificationOutboxService.get(db, id)
+    return success(data=obj)
+
+
+@admin_required_router.get("/notification/outbox/list", summary="分页查询通知列表", tags=["消息推送接口"], response_model=ApiResponse[PageResponse[NotificationOutboxOut]])
+async def notification_outbox_list(
+    status: str = Query("", description="状态"),
+    channel: str = Query("", description="渠道"),
+    priority: int = Query(0, description="优先级"),
+    msg_id: str = Query("", description="消息ID"),
+    page: int = Query(1, description="第几页"),
+    size: int = Query(20, description="分页大小"),
+    db: AsyncSession = Depends(get_db)
+):
+    obj = await NotificationOutboxService.list(db, status, channel, priority, msg_id, page, size)
+    return success(data=obj)
+

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

@@ -0,0 +1,141 @@
+from typing import List
+from fastapi import APIRouter, Query, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.utils.validation_utils import validate_user_inputs
+from app.core.redis import get_redis_client
+from app.core.database import get_db
+from app.core.auth import get_current_user
+from redis.asyncio import Redis
+from app.utils.response import success
+from app.models.user import VasUser
+from app.schemas.common import ApiResponse, PageResponse
+from app.schemas.order import VasOrderAdjustPrice, VasOrderCreate, VasOrderOut, VasOrderPatchUserInputs
+from app.schemas.order_event import VasOrderEventCreate, VasOrderEventOut
+from app.services.order_event_service import OrderEventService
+from app.services.order_service import OrderService
+from app.services.product_service import ProductService
+from app.services.schema_service import SchemaService
+
+public_router = APIRouter()
+protected_router = APIRouter()
+admin_required_router = APIRouter()
+
+
+@protected_router.post("/vas/order/create", summary="创建订单", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
+async def vas_order_create(
+    payload: VasOrderCreate,
+    current_user: VasUser = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+    redis_client: Redis = Depends(get_redis_client)
+):
+    product = await ProductService.get(db, payload.product_id)
+    # ① 获取产品绑定的 schema
+    schema = await SchemaService.get(db, product.schema_id)
+    # ② 校验 user_inputs
+    validate_user_inputs(
+        schema_json=schema.schema_json,
+        user_inputs=payload.user_inputs,
+    )
+    created_order = await OrderService.create(db, payload, product, current_user, redis_client)
+    return success(data=created_order)
+
+
+@admin_required_router.post("/vas/order/create_by_admin", summary="管理员创建订单", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
+async def vas_order_create_by_admin(
+    payload: VasOrderCreate,
+    current_user: VasUser = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    product = await ProductService.get(db, payload.product_id)
+    # ① 获取产品绑定的 schema
+    schema = await SchemaService.get(db, product.schema_id)
+    # ② 校验 user_inputs
+    validate_user_inputs(
+        schema_json=schema.schema_json,
+        user_inputs=payload.user_inputs,
+    )
+    created_order = await OrderService.create_by_admin(db, payload, product, current_user)
+    return success(data=created_order)
+
+
+@admin_required_router.post("/vas/order/adjust-price", summary="管理员调整订单价格", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
+async def vas_order_adjust_price(
+    order_id: str,
+    payload: VasOrderAdjustPrice,
+    db: AsyncSession = Depends(get_db),
+    current_user: VasUser = Depends(get_current_user)
+):
+    order = await OrderService.adjust_order_price(db, order_id, payload)
+    return success(data=order)
+
+
+@admin_required_router.get("/vas/order/detail", summary="查询订单", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
+async def vas_order_create(
+    order_id: str,
+    db: AsyncSession = Depends(get_db),
+):
+    order = await OrderService.get(db, order_id)
+    return success(data=order)
+
+
+@admin_required_router.post("/vas/order/patch_user_inputs", summary="更新订单的用户信息", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
+async def vas_order_patch_user_inputs(
+    order_id: str,
+    payload: VasOrderPatchUserInputs,
+    db: AsyncSession = Depends(get_db),
+):
+    order = await OrderService.patch_user_inputs(db, order_id, payload)
+    return success(data=order)
+
+
+@protected_router.get("/vas/order/list_by_user", summary="查看所有订单", tags=["textskin"], response_model=ApiResponse[PageResponse[VasOrderOut]])
+async def vas_order_list_by_user(
+    page: int = Query(0, description="第几页"),
+    size: int = Query(10, description="分页大小"),
+    keyword: str = Query("", description="查询条件"),
+    current_user: VasUser = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    orders = await OrderService.list_by_user(db, current_user.id, page, size, keyword)
+    return success(data=orders)
+
+
+@protected_router.get("/vas/order/list_all", summary="查看所有订单", tags=["textskin"], response_model=ApiResponse[PageResponse[VasOrderOut]])
+async def vas_order_list_all(
+    page: int = Query(0, description="第几页"),
+    size: int = Query(10, description="分页大小"),
+    keyword: str = Query("", description="查询条件"),
+    db: AsyncSession = Depends(get_db)
+):
+    orders = await OrderService.list_all(db, page, size, keyword)
+    return success(data=orders)
+
+
+@admin_required_router.post("/vas/order/cancel", summary="取消订单", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
+async def vas_order_cancel(
+    order_id: str,
+    current_user: VasUser = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+    redis_client: Redis = Depends(get_redis_client)
+):
+    cancelled_order = await OrderService.cancel(db, order_id)
+    return success(data=cancelled_order)
+
+
+@admin_required_router.post("/vas/order-event/create", summary="创建订单事件", tags=["textskin"], response_model=ApiResponse[VasOrderEventOut])
+async def vas_order_event_create(
+    event_data: VasOrderEventCreate,
+    db: AsyncSession = Depends(get_db)
+):
+    obj = await OrderEventService.create(db, event_data)
+    return success(data=obj)
+
+
+@protected_router.get("/vas/order-event/list", summary="获取订单的所有事件", tags=["textskin"], response_model=ApiResponse[List[VasOrderEventOut]])
+async def vas_list_order_events_by_order(
+    order_id: str,
+    db: AsyncSession = Depends(get_db)
+):
+    events = await OrderEventService.get_by_order_id(db, order_id)
+    return success(data=events)
+

+ 173 - 0
app/api/endpoints/payment.py

@@ -0,0 +1,173 @@
+from typing import List
+from fastapi import APIRouter, Query, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.redis import get_redis_client
+from app.core.database import get_db
+from app.core.auth import get_current_user
+from redis.asyncio import Redis
+from app.utils.response import success
+from app.models.user import VasUser
+from app.schemas.common import ApiResponse, PageResponse
+from app.schemas.payment import AdminUpdateStatusPayload, VasPaymentCreate, VasPaymentOut
+from app.schemas.payment_confirmation import VasPaymentConfirmationCreate, VasPaymentConfirmationOut, VasPaymentConfirmationUpdate
+from app.schemas.payment_provider import VasPaymentProviderCreate, VasPaymentProviderOut, VasPaymentProviderUpdate
+from app.schemas.payment_qr import VasPaymentQrCreate, VasPaymentQrOut, VasPaymentQrSetEnableIn
+from app.services.payment_provider_service import PaymentProviderService
+from app.services.payment_qr_service import PaymentQrService
+from app.services.payment_service import PaymentService
+
+public_router = APIRouter()
+protected_router = APIRouter()
+admin_required_router = APIRouter()
+
+
+@protected_router.get("/vas/payment_provider/list_enabled", summary="获取支付方式", tags=["textskin"], response_model=ApiResponse[List[VasPaymentProviderOut]])
+async def vas_payment_provider_simple_get(
+    db: AsyncSession = Depends(get_db)
+):
+    providers = await PaymentProviderService.list_enabled(db)
+    return success(data=providers)
+
+
+@admin_required_router.get("/vas/payment_provider/list_all", summary="获取支付方式", tags=["textskin"], response_model=ApiResponse[List[VasPaymentProviderOut]])
+async def vas_payment_provider_list_all(
+    db: AsyncSession = Depends(get_db)
+):
+    providers = await PaymentProviderService.list_all(db)
+    return success(data=providers)
+
+
+@admin_required_router.post("/vas/payment_provider/create", summary="新增支付服务提供商", tags=["textskin"], response_model=ApiResponse[VasPaymentProviderOut])
+async def vas_payment_provider_create(
+    payload: VasPaymentProviderCreate,
+    db: AsyncSession = Depends(get_db)
+):
+    provider = await PaymentProviderService.create(db, payload)
+    return success(data=provider)
+
+
+@admin_required_router.post("/vas/payment_provider/update", summary="更新支付服务提供商", tags=["textskin"], response_model=ApiResponse[VasPaymentProviderOut])
+async def vas_payment_provider_update(
+    id: int,
+    payload: VasPaymentProviderUpdate,
+    db: AsyncSession = Depends(get_db)
+):
+    provider = await PaymentProviderService.update(db, id, payload)
+    return success(data=provider)
+
+
+@admin_required_router.delete("/vas/payment_provider/delete", summary="删除支付服务提供商", tags=["textskin"], response_model=ApiResponse)
+async def vas_payment_provider_delete(
+    id: int,
+    db: AsyncSession = Depends(get_db)
+):
+    await PaymentProviderService.delete(db, id)
+    return success()
+
+
+@protected_router.post("/vas/payment/create", summary="创建支付", tags=["textskin"], response_model=ApiResponse[VasPaymentOut])
+async def vas_payment_create(
+    payload: VasPaymentCreate,
+    db: AsyncSession = Depends(get_db),
+    redis_client: Redis = Depends(get_redis_client)
+):
+    res = await PaymentService.create_payment(db, payload, redis_client)
+    return success(data=res)
+
+
+@protected_router.get("/vas/payment/detail", summary="获取支付详情", tags=["textskin"], response_model=ApiResponse[VasPaymentOut])
+async def vas_payment_create(
+    payment_id: int,
+    db: AsyncSession = Depends(get_db),
+):
+    res = await PaymentService.get_by_id(db, payment_id)
+    return success(data=res)
+
+
+@admin_required_router.post("/vas/payment/confirm_by_admin", summary="管理员确认支付", tags=["textskin"], response_model=ApiResponse[VasPaymentConfirmationOut])
+async def vas_payment_confirm_by_admin(
+    id: int,
+    payload: VasPaymentConfirmationUpdate,
+    current_user: VasUser = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    res = await PaymentService.confirm_by_admin(db, id, payload, current_user)
+    return success(data=res)
+
+
+@admin_required_router.post("/vas/payment/admin_update_status", summary="管理员更新支付状态", tags=["textskin"], response_model=ApiResponse[VasPaymentOut])
+async def vas_payment_admin_update_status(
+    payment_id: int,
+    payload: AdminUpdateStatusPayload,
+    db: AsyncSession = Depends(get_db)
+):
+    res = await PaymentService.admin_update_status(db, payment_id, payload)
+    return success(data=res)
+
+
+@protected_router.post("/vas/payment/confirm_by_user", summary="用户确认支付", tags=["textskin"], response_model=ApiResponse[VasPaymentConfirmationOut])
+async def vas_payment_confirm_by_user(
+    payload: VasPaymentConfirmationCreate,
+    current_user: VasUser = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    res = await PaymentService.confirm_by_user(db, payload, current_user)
+    return success(data=res)
+
+
+@admin_required_router.post("/vas/payment_confirmation/list_all", summary="查询所有待确认支付", tags=["textskin"], response_model=ApiResponse[PageResponse[VasPaymentConfirmationOut]])
+async def vas_payment_confirm_list(
+    page: int = Query(0, description="第几页"),
+    size: int = Query(10, description="分页大小"),
+    keyword: str = Query("", description="查询条件"),
+    db: AsyncSession = Depends(get_db)
+):
+    res = await PaymentService.list_payment_confirmation(db, keyword, page, size)
+    return success(data=res)
+
+
+@protected_router.get("/vas/payment/list_by_order", summary="获取某个订单下的所有payment记录", tags=["textskin"], response_model=ApiResponse[List[VasPaymentOut]])
+async def vas_payment_list_by_order(
+    order_id: str,
+    db: AsyncSession = Depends(get_db)
+):
+    payments = await PaymentService.list_by_order(db, order_id)
+    return success(data=payments)
+
+
+@admin_required_router.post("/vas/payment_qr/create", summary="新增收款码", tags=["textskin"], response_model=ApiResponse[VasPaymentQrOut])
+async def vas_payment_qr_create(payload: VasPaymentQrCreate, db: AsyncSession = Depends(get_db)):
+    qr = await PaymentQrService.create(db, payload)
+    return success(data=qr)
+
+
+@protected_router.get("/vas/payment_qr/list_by_provider", summary="获取某个服务商的所有付款码", tags=["textskin"], response_model=ApiResponse[List[VasPaymentQrOut]])
+async def vas_payment_qr_list_qrcode_by_provider(provider_id: int, db: AsyncSession = Depends(get_db)):
+    qr = await PaymentQrService.list_by_provider(db, provider_id)
+    return success(data=qr)
+
+
+@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)
+    return success(data=qr)
+
+
+@admin_required_router.post("/vas/payment_qr/set_enable", summary="修改QRCode", tags=["textskin"], response_model=ApiResponse[VasPaymentQrOut])
+async def vas_payment_qr_update(
+    id: int,
+    payload: VasPaymentQrSetEnableIn,
+    db: AsyncSession = Depends(get_db)
+):
+    qr = await PaymentQrService.set_enable(db, id, payload)
+    return success(data=qr)
+
+
+@admin_required_router.delete("/vas/payment_qr/delete", summary="删除QRCode", tags=["textskin"], response_model=ApiResponse)
+async def vas_payment_qr_update(
+    id: int,
+    db: AsyncSession = Depends(get_db)
+):
+    await PaymentQrService.delete(db, id)
+    return success()
+

+ 143 - 0
app/api/endpoints/product.py

@@ -0,0 +1,143 @@
+from typing import List
+from fastapi import APIRouter, Query, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.utils.response import success
+from app.schemas.common import ApiResponse, PageResponse
+from app.schemas.product import VasProductCreate, VasProductOut, VasProductUpdate
+from app.schemas.product_routing import VasProductRoutingCreate, VasProductRoutingOut
+from app.schemas.schema import VasSchemaCreate, VasSchemaOut, VasSchemaUpdate
+from app.services.product_routing_service import ProductRoutingService
+from app.services.product_service import ProductService
+from app.services.schema_service import SchemaService
+
+public_router = APIRouter()
+protected_router = APIRouter()
+admin_required_router = APIRouter()
+
+
+@admin_required_router.post("/vas/product/create", summary="创建商品", tags=["textskin"], response_model=ApiResponse[VasProductOut])
+async def vas_product_create(
+    payload: VasProductCreate,
+    db: AsyncSession = Depends(get_db)
+):
+    created_product = await ProductService.create(db, payload)
+    return success(data=created_product)
+
+
+@admin_required_router.post("/vas/product/update", summary="更新商品", tags=["textskin"], response_model=ApiResponse[VasProductOut])
+async def vas_product_update(
+    id: int,
+    payload: VasProductUpdate,
+    db: AsyncSession = Depends(get_db)
+):
+    product = await ProductService.update(db, id, payload)
+    return success(data=product)
+
+
+@public_router.get("/vas/product/list-enable", summary="获取商品列表", tags=["textskin"], response_model=ApiResponse[PageResponse[VasProductOut]])
+async def vas_product_list(
+    country: str = Query("", description="目的国家"),
+    visa_type: str = Query("", description="签证类型"),
+    page: int = Query(0, description="第几页"),
+    size: int = Query(10, description="分页大小"),
+    keyword: str = Query("", description="查询条件"),
+    db: AsyncSession = Depends(get_db)
+):
+    products = await ProductService.list_enable_product(db, country, visa_type, page, size, keyword)
+    return success(data=products)
+
+
+@admin_required_router.get("/vas/product/list", summary="获取商品列表", tags=["textskin"], response_model=ApiResponse[PageResponse[VasProductOut]])
+async def vas_product_list(
+    country: str = Query("", description="目的国家"),
+    visa_type: str = Query("", description="签证类型"),
+    page: int = Query(0, description="第几页"),
+    size: int = Query(10, description="分页大小"),
+    keyword: str = Query("", description="查询条件"),
+    db: AsyncSession = Depends(get_db)
+):
+    products = await ProductService.list_product(db, country, visa_type, page, size, keyword)
+    return success(data=products)
+
+
+@public_router.get("/vas/product/detail", summary="获取商品列表", tags=["textskin"], response_model=ApiResponse[VasProductOut])
+async def vas_product_get_by_id(
+    product_id: int,
+    db: AsyncSession = Depends(get_db)
+):
+    products = await ProductService.get(db, product_id)
+    return success(data=products)
+
+
+@admin_required_router.post("/vas/product_routing/create", summary="创建商品路由列表", tags=["textskin"], response_model=ApiResponse[VasProductRoutingOut])
+async def vas_product_routing_create(
+    payload: VasProductRoutingCreate,
+    db: AsyncSession = Depends(get_db)
+):
+    payload = await ProductRoutingService.create(db, payload)
+    return success(data=payload)
+
+
+@admin_required_router.delete("/vas/product_routing/delete", summary="删除商品路由列表", tags=["textskin"], response_model=ApiResponse)
+async def vas_product_routing_date(
+    id: int,
+    db: AsyncSession = Depends(get_db)
+):
+    await ProductRoutingService.delete(db, id)
+    return success()
+
+
+@admin_required_router.get("/vas/product_routing/list", summary="获取商品路由列表", tags=["textskin"], response_model=ApiResponse[List[VasProductRoutingOut]])
+async def vas_product_routing_list_by_product(
+    product_id: int,
+    db: AsyncSession = Depends(get_db)
+):
+    product_routings = await ProductRoutingService.list_by_product(db, product_id)
+    return success(data=product_routings)
+
+
+@public_router.get("/vas/schema/detail", summary="获取schema", tags=["textskin"], response_model=ApiResponse[VasSchemaOut])
+async def vas_schema_get(
+    schema_id: int,
+    db: AsyncSession = Depends(get_db)
+):
+    schema = await SchemaService.get(db, schema_id)
+    return success(data=schema)
+
+
+@admin_required_router.post("/vas/schema/create", summary="新增schema", tags=["textskin"], response_model=ApiResponse[VasSchemaOut])
+async def vas_schema_create(
+    payload: VasSchemaCreate,
+    db: AsyncSession = Depends(get_db)
+):
+    schema = await SchemaService.create(db, payload)
+    return success(data=schema)
+
+
+@admin_required_router.post("/vas/schema/update", summary="更新schema", tags=["textskin"], response_model=ApiResponse[VasSchemaOut])
+async def vas_schema_update(
+    id: int,
+    payload: VasSchemaUpdate,
+    db: AsyncSession = Depends(get_db)
+):
+    schema = await SchemaService.update(db, id, payload)
+    return success(data=schema)
+
+
+@admin_required_router.delete("/vas/schema/delete", summary="删除schema", tags=["textskin"], response_model=ApiResponse)
+async def vas_schema_delete(
+    id: int,
+    db: AsyncSession = Depends(get_db)
+):
+    await SchemaService.delete(db, id)
+    return success()
+
+
+@admin_required_router.get("/vas/schema/list", summary="获取schema列表", tags=["textskin"], response_model=ApiResponse[List[VasSchemaOut]])
+async def vas_schema_list(
+    db: AsyncSession = Depends(get_db)
+):
+    schemas = await SchemaService.list_all(db)
+    return success(data=schemas)
+

+ 60 - 0
app/api/endpoints/proxy.py

@@ -0,0 +1,60 @@
+from fastapi import APIRouter, Query, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.utils.response import success
+from app.schemas.common import ApiResponse, PageResponse
+from app.schemas.proxy_pool import GetNextIpPayload, ProxyCreate, ProxyOut, ProxyUpdate
+from app.services.proxy_service import ProxyService
+
+public_router = APIRouter()
+protected_router = APIRouter()
+admin_required_router = APIRouter()
+
+
+@admin_required_router.post("/proxy/create", summary="创建代理", tags=["代理管理"], response_model=ApiResponse[ProxyOut])
+async def proxy_create(
+    payload: ProxyCreate,
+    db: AsyncSession = Depends(get_db)
+):
+    proxy = await ProxyService.create_proxy(db, payload)
+    return success(data=proxy)
+
+
+@admin_required_router.put("/proxy/update", summary="更新代理", tags=["代理管理"], response_model=ApiResponse[ProxyOut])
+async def proxy_update(
+    proxy_id: int,
+    payload: ProxyUpdate,
+    db: AsyncSession = Depends(get_db)
+):
+    proxy = await ProxyService.update_proxy(db, proxy_id, payload)
+    return success(data=proxy)
+
+
+@admin_required_router.delete("/proxy/delete", summary="删除代理", tags=["代理管理"], response_model=ApiResponse)
+async def proxy_remove(
+    proxy_id: int,
+    db: AsyncSession = Depends(get_db)
+):
+    await ProxyService.remove_proxy(db, proxy_id)
+    return success()
+
+
+@admin_required_router.get("/proxy/list_all", summary="查询代理", tags=["代理管理"], response_model=ApiResponse[PageResponse[ProxyOut]])
+async def proxy_list(
+    page: int = Query(0, description="第几页"),
+    size: int = Query(10, description="分页大小"),
+    keyword: str = Query("", description="查询条件"),
+    db: AsyncSession = Depends(get_db)
+):
+    obj = await ProxyService.list_proxy(db, page, size, keyword)
+    return success(data=obj)
+
+
+@admin_required_router.post("/proxy/next-ip", summary="获取下一个ip", tags=["代理管理"], response_model=ApiResponse[ProxyOut])
+async def proxy_next_ip_get(
+    payload: GetNextIpPayload,
+    db: AsyncSession = Depends(get_db)
+):
+    proxy = await ProxyService.get_next_ip(db, payload.pools, payload.proxy_cd)
+    return success(data=proxy)
+

+ 74 - 0
app/api/endpoints/slot.py

@@ -0,0 +1,74 @@
+from typing import List
+from fastapi import APIRouter, Query, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.redis import get_redis_client
+from app.core.database import get_db
+from redis.asyncio import Redis
+from app.utils.response import success
+from app.schemas.common import ApiResponse
+from app.schemas.slot_refresh_status import RefreshBase, RefreshFail, RefreshStatusOut
+from app.schemas.slot_snapshot import SlotOverviewOut, SlotSnapshotCreate, SlotSnapshotOut
+from app.services.slot_refresh_status_service import SlotRefreshStatusService
+from app.services.slot_snapshot_service import SlotSnapshotService
+
+public_router = APIRouter()
+protected_router = APIRouter()
+admin_required_router = APIRouter()
+
+
+@public_router.get("/slots/latest", summary="查询最近的slot", tags=["Slot数据"], response_model=ApiResponse[SlotSnapshotOut])
+async def slots_latest_get(
+    country: str = Query("", description="目的国家"),
+    city: str = Query("", description="递交城市"),
+    visa_type: str = Query("", description="签证类型"),
+    db: AsyncSession = Depends(get_db)
+):
+    res = await SlotSnapshotService.latest_for(db, country, city, visa_type)
+    return success(data=res)
+
+
+@public_router.get("/slots/overview", summary="查询最近的slot", tags=["Slot数据"], response_model=ApiResponse[List[SlotOverviewOut]])
+async def slots_latest_get(
+    city: str = Query("", description="递交城市"),
+    db: AsyncSession = Depends(get_db)
+):
+    res = await SlotSnapshotService.get_slot_overview(db, city)
+    return success(data=res)
+
+
+@admin_required_router.post("/slots/report", summary="上报最近的slot", tags=["Slot数据"], response_model=ApiResponse[SlotSnapshotOut])
+async def slots_report(
+    payload: SlotSnapshotCreate,
+    db: AsyncSession = Depends(get_db),
+    redis_client: Redis = Depends(get_redis_client)
+):
+    res = await SlotSnapshotService.report(db, redis_client, payload)
+    return success(data=res)
+
+
+@admin_required_router.post("/slot_refresh/start", summary="刷新slot开始", tags=["Slot Monitor 监控"], response_model=ApiResponse[RefreshStatusOut])
+async def slot_refresh_start(data: RefreshBase, db: AsyncSession = Depends(get_db)
+):
+    data = await SlotRefreshStatusService.refresh_start(db, data)
+    return success(data=data)
+
+
+@admin_required_router.post("/slot_refresh/success", summary="刷新slot成功", tags=["Slot Monitor 监控"], response_model=ApiResponse[RefreshStatusOut])
+async def  slot_refresh_success(data: RefreshBase, db: AsyncSession = Depends(get_db)
+):
+    data = await SlotRefreshStatusService.refresh_success(db, data)
+    return success(data=data)
+
+
+@admin_required_router.post("/slot_refresh/fail", summary="刷新slot失败", tags=["Slot Monitor 监控"], response_model=ApiResponse[RefreshStatusOut])
+async def slot_refresh_fail(data: RefreshFail,db: AsyncSession = Depends(get_db)
+):
+    data = await SlotRefreshStatusService.refresh_fail(db, data)
+    return success(data=data)
+
+
+@admin_required_router.get("/slot_refresh/status", summary="查询刷新纪录", tags=["Slot Monitor 监控"], response_model=ApiResponse[List[RefreshStatusOut]])
+async def slot_refresh_status(db: AsyncSession = Depends(get_db)):
+    data = await SlotRefreshStatusService.list_all(db)
+    return success(data=data)
+

+ 55 - 0
app/api/endpoints/sms.py

@@ -0,0 +1,55 @@
+import time
+from typing import List
+from fastapi import APIRouter, Query, Depends
+from app.core.redis import get_redis_client
+from redis.asyncio import Redis
+from app.utils.response import success
+from app.schemas.common import ApiResponse
+from app.schemas.sms import ShortMessageDetail, SmsSendIn
+from app.services.sms_service import query_short_message, save_short_message, send_sms
+
+public_router = APIRouter()
+protected_router = APIRouter()
+admin_required_router = APIRouter()
+
+
+@admin_required_router.get("/sms/upload", summary="上报短信", tags=["短信接口"], response_model=ApiResponse[ShortMessageDetail])
+async def sms_upload(
+    phone: str = Query(..., description="手机号"),
+    message: str = Query(..., description="短信内容"),
+    max_ttl: int = Query(300, description="短信保存时间(秒)"),
+    redis_client: Redis = Depends(get_redis_client)
+):
+    """
+    保存短信到 Redis
+    """
+    received_at = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+    msg = await save_short_message(redis_client, phone, message, received_at, max_ttl)
+    return success(data=msg)
+
+
+@admin_required_router.get("/sms/download", summary="读取短信", tags=["短信接口"], response_model=ApiResponse[List[ShortMessageDetail]])
+async def sms_download(
+    phone: str = Query(..., description="手机号"),
+    keyword: str = Query('', description="短信内容关键字"),
+    sent_at: str = Query('', description="筛选时间(可选)"),
+    redis_client: Redis = Depends(get_redis_client)
+):
+    """
+    查询短信(支持关键字和时间过滤)
+    """
+    obj = await query_short_message(redis_client, phone, keyword or None, sent_at or None)
+    return success(data=obj)
+
+
+@admin_required_router.post("/sms/send", summary="发送短信", tags=["短信接口"], response_model=ApiResponse[str])
+async def sms_send(
+    payload: SmsSendIn,
+):
+    res = await send_sms(
+        send_to=payload.send_to,
+        sender=payload.sender,
+        content=payload.content,
+    )
+    return success(data=res)
+

+ 54 - 0
app/api/endpoints/task.py

@@ -0,0 +1,54 @@
+from typing import List
+from fastapi import APIRouter, Query, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.utils.response import success
+from app.schemas.common import ApiResponse
+from app.schemas.task import TaskCreate, TaskOut, TaskUpdate
+from app.services.task_service import TaskService
+
+public_router = APIRouter()
+protected_router = APIRouter()
+admin_required_router = APIRouter()
+
+
+@admin_required_router.post("/tasks", summary="创建任务", tags=["任务管理接口"], response_model=ApiResponse[TaskOut])
+async def task_create(data: TaskCreate, db: AsyncSession = Depends(get_db)):
+    """创建任务"""
+    task = await TaskService.create(db, data)
+    return success(data=task)
+
+
+@admin_required_router.get("/tasks/{task_id:int}", summary="根据taskId读取任务状态", tags=["任务管理接口"], response_model=ApiResponse[TaskOut])
+async def task_get_by_id(task_id: int, db: AsyncSession = Depends(get_db)):
+    """获取任务"""
+    task = await TaskService.get_by_id(db, task_id)
+    return success(data=task)
+
+
+@admin_required_router.get("/tasks/pending", summary="获取等待执行的任务", tags=["任务管理接口"], response_model=ApiResponse[List[TaskOut]])
+async def task_get_pending(
+    page: int = Query(0, description="第几页"),
+    size: int = Query(10, description="分页大小"),
+    command: str = Query(..., description="任务类型"),
+    db: AsyncSession = Depends(get_db),
+):
+    """分页获取等待执行的任务"""
+    obj = await TaskService.get_pending(db, command, page, size)
+    return success(data=obj)
+
+
+@admin_required_router.put("/tasks/{task_id}", summary="根据taskId更新任务状态", tags=["任务管理接口"], response_model=ApiResponse[TaskOut])
+async def task_update_by_id(task_id: int, data: TaskUpdate, db: AsyncSession = Depends(get_db)):
+    """更新任务状态或结果"""
+    updated = await TaskService.update(db, task_id, data)
+    return success(data=updated)
+
+
+@admin_required_router.get("/task/pop", summary="任务出队(pop)", tags=["任务管理接口"], response_model=ApiResponse[TaskOut])
+async def task_pop_task(
+    queue_name: str,
+    db: AsyncSession = Depends(get_db),
+):
+    task = await TaskService.pop_task(db, queue_name)
+    return success(data=task)

+ 101 - 0
app/api/endpoints/ticket.py

@@ -0,0 +1,101 @@
+from fastapi import APIRouter, Query, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.redis import get_redis_client
+from app.core.database import get_db
+from app.core.auth import get_current_user
+from redis.asyncio import Redis
+from app.utils.response import success
+from app.models.user import VasUser
+from app.schemas.common import ApiResponse, PageResponse
+from app.schemas.ticket import VasTicketCreate, VasTicketMessageCreate, VasTicketMessageOut, VasTicketOut, VasTicketStatusUpdate
+from app.services.ticket_service import TicketService
+
+public_router = APIRouter()
+protected_router = APIRouter()
+admin_required_router = APIRouter()
+
+
+@protected_router.post("/vas/ticket/create", summary="创建工单", tags=["textskin"], response_model=ApiResponse[VasTicketOut])
+async def vas_ticket_create(
+    data:VasTicketCreate,
+    current_user: VasUser = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+    redis_client: Redis = Depends(get_redis_client)
+):
+    obj = await TicketService.create(db, data, current_user, redis_client)
+    return success(data=obj)
+
+
+@protected_router.get("/vas/ticket/list_by_user", summary="查看工单", tags=["textskin"], response_model=ApiResponse[PageResponse[VasTicketOut]])
+async def vas_ticket_list_by_user(
+    page: int = Query(0, description="第几页"),
+    size: int = Query(10, description="分页大小"),
+    keyword: str = Query("", description="查询条件"),
+    current_user: VasUser = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    tickets = await TicketService.list_by_user(db, current_user.id, page, size, keyword)
+    return success(data=tickets)
+
+
+@admin_required_router.get("/vas/ticket/list_all", summary="查看工单", tags=["textskin"], response_model=ApiResponse[PageResponse[VasTicketOut]])
+async def vas_ticket_list_all(
+    page: int = Query(0, description="第几页"),
+    size: int = Query(10, description="分页大小"),
+    keyword: str = Query("", description="查询条件"),
+    db: AsyncSession = Depends(get_db)
+):
+    tickets = await TicketService.list_all(db, page, size, keyword)
+    return success(data=tickets)
+
+
+@admin_required_router.post("/vas/tickets/status", summary="管理员更新工单状态", tags=["textskin"], response_model=ApiResponse[VasTicketOut])
+async def update_ticket_status(
+    ticket_id: int,
+    payload: VasTicketStatusUpdate,
+    db: AsyncSession = Depends(get_db),
+    user=Depends(get_current_user)
+):
+    res = await TicketService.update_status(
+        db=db,
+        ticket_id=ticket_id,
+        status=payload.status,
+        comment=payload.comment,
+        admin_id=user.id
+    )
+    return success(data=res)
+
+
+@protected_router.post("/vas/tickets/send_message", summary="发送工单消息", tags=["textskin"], response_model=ApiResponse[VasTicketMessageOut])
+async def create_ticket_message(
+    ticket_id: int,
+    payload: VasTicketMessageCreate,
+    db: AsyncSession = Depends(get_db),
+    user=Depends(get_current_user)
+):
+    res = await TicketService.add_message(
+        db=db,
+        ticket_id=ticket_id,
+        sender_type=user.role,
+        sender_id=user.id,
+        content=payload.content,
+        attachments=payload.attachments
+    )
+    return success(data=res)
+
+
+@protected_router.get("/vas/tickets/fetch_message", summary="分页获取工单会话", tags=["textskin"], response_model=ApiResponse[PageResponse[VasTicketMessageOut]])
+async def get_ticket_messages(
+    ticket_id: int,
+    page: int = 1,
+    size: int = 20,
+    db: AsyncSession = Depends(get_db)
+):
+    msgs = await TicketService.list_messages(
+        db=db,
+        ticket_id=ticket_id,
+        page=page,
+        size=size
+    )
+    return success(data=msgs)
+

+ 54 - 0
app/api/endpoints/user.py

@@ -0,0 +1,54 @@
+from fastapi import APIRouter, Query, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.core.auth import get_current_user
+from app.utils.response import success
+from app.models.user import VasUser
+from app.schemas.common import ApiResponse, PageResponse
+from app.schemas.user import VasUserOut, VasUserSetProfiles, VasUserUpdate
+from app.services.user_service import UserService
+
+public_router = APIRouter()
+protected_router = APIRouter()
+admin_required_router = APIRouter()
+
+
+@admin_required_router.get("/user/list_all", summary="获取所有用户", tags=["用户管理"], response_model=ApiResponse[PageResponse[VasUserOut]])
+async def vas_user_list_all(
+    page: int = Query(0, description="第几页"),
+    size: int = Query(10, description="分页大小"),
+    keyword: str = Query("", description="查询条件"),
+    db: AsyncSession = Depends(get_db)
+):
+    users = await UserService.list_all(db, page, size, keyword)
+    return success(data=users)
+
+
+@admin_required_router.get("/user/detail", summary="获取用户信息", tags=["用户管理"], response_model=ApiResponse[VasUserOut])
+async def vas_user_get_detail(
+    user_id: str,
+    db: AsyncSession = Depends(get_db)
+):
+    user = await UserService.get(db, user_id)
+    return success(data=user)
+
+
+@admin_required_router.post("/user/update", summary="更新用户信息", tags=["用户管理"], response_model=ApiResponse[VasUserOut])
+async def vas_user_update(
+    uid: str,
+    payload: VasUserUpdate,
+    db: AsyncSession = Depends(get_db)
+):
+    updated = await UserService.update(db, uid, payload)
+    return success(data=updated)
+
+
+@protected_router.post("/user/set_profiles", summary="更新用户信息", tags=["用户管理"], response_model=ApiResponse[VasUserOut])
+async def vas_user_update(
+    payload: VasUserSetProfiles,
+    current_user: VasUser = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    updated = await UserService.set_profiles(db, current_user, payload)
+    return success(data=updated)
+

+ 99 - 0
app/api/endpoints/vas_task.py

@@ -0,0 +1,99 @@
+from typing import List
+from fastapi import APIRouter, Query, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.redis import get_redis_client
+from app.core.database import get_db
+from redis.asyncio import Redis
+from app.utils.response import success
+from app.schemas.common import ApiResponse, PageResponse
+from app.schemas.vas_task import VasExpiringTaskItem, VasTaskOut, VasTaskUpdate
+from app.services.vas_task_service import VasTaskService
+
+public_router = APIRouter()
+protected_router = APIRouter()
+admin_required_router = APIRouter()
+
+
+@admin_required_router.get("/vas/task/list", summary="获取待执行的任务", tags=["textskin"], response_model=ApiResponse[PageResponse[VasTaskOut]])
+async def vas_task_list(
+    page: int = Query(0, description="第几页"),
+    size: int = Query(10, description="分页大小"),
+    keyword: str = Query("", description="查询条件"),
+    status: str = Query("", description="task 自定义索引"),
+    routing_key: str = Query("", description="task 自定义索引"),
+    script_version: str = Query("", description="脚本版本, 用来向后兼容"),
+    db: AsyncSession = Depends(get_db)
+):
+    tasks = await VasTaskService.list_task(db, status, routing_key, script_version, keyword, page, size)
+    return success(data=tasks)
+
+
+@admin_required_router.get("/vas/task/expiring", summary="获取即将过期的任务列表", tags=["textskin"], response_model=ApiResponse[List[VasExpiringTaskItem]])
+async def vas_task_get_expiring_tasks(
+    days: int = 3,
+    db: AsyncSession = Depends(get_db)
+):
+    """获取即将过期的任务列表"""
+    tasks = await VasTaskService.get_expiring_tasks(db, threshold_days=days)
+    return success(data=tasks)
+
+
+@admin_required_router.post("/vas/task/update", summary="更新任务数据", tags=["textskin"], response_model=ApiResponse[VasTaskOut])
+async def vas_task_update(
+    id: int,
+    payload: VasTaskUpdate,
+    db: AsyncSession = Depends(get_db)
+):
+    task = await VasTaskService.update(db, id, payload)
+    return success(data=task)
+
+
+@admin_required_router.get("/vas/task/get_by_order", summary="根据订单查找任务", tags=["textskin"], response_model=ApiResponse[List[VasTaskOut]])
+async def vas_task_query_by_order(
+    order_id: str = Query(..., description="订单编号"),
+    script_version: str = Query("", description="脚本版本, 用来向后兼容"),
+    db: AsyncSession = Depends(get_db)
+):
+    tasks = await VasTaskService.get_task_by_order_id(db, order_id)
+    return success(data=tasks)
+
+
+@admin_required_router.post("/vas/task/pause", summary="暂停任务", tags=["textskin"], response_model=ApiResponse[VasTaskOut])
+async def vas_task_pause(task_id: int, db: AsyncSession = Depends(get_db)):
+    obj = await VasTaskService.pause(db, task_id)
+    return success(data=obj)
+
+
+@admin_required_router.get("/vas/task/detail", summary="根据taskid查找任务", tags=["textskin"], response_model=ApiResponse[VasTaskOut])
+async def vas_task_query_by_id(
+    task_id: int = Query(..., description="任务Id"),
+    db: AsyncSession = Depends(get_db)
+):
+    task = await VasTaskService.get_task_by_id(db, task_id)
+    return success(data=task)
+
+
+@admin_required_router.post("/vas/task/return_to_queue", summary="重新进入等候状态", tags=["textskin"], response_model=ApiResponse[VasTaskOut])
+async def vas_task_return_to_queue(task_id: int, db: AsyncSession = Depends(get_db)):
+    obj = await VasTaskService.return_to_queue(db, task_id)
+    return success(data=obj)
+
+
+@admin_required_router.post("/vas/task/manual_confirm", summary="设置任务完成", tags=["textskin"], response_model=ApiResponse[VasTaskOut])
+async def vas_task_manual_confirm(
+    task_id: int,
+    db: AsyncSession = Depends(get_db),
+    redis_client: Redis = Depends(get_redis_client)
+):
+    obj = await VasTaskService.manual_confirm(db, task_id, redis_client)
+    return success(data=obj)
+
+
+@admin_required_router.get("/vas/task/pop", summary="任务出队(pop)", tags=["textskin"], response_model=ApiResponse[VasTaskOut])
+async def vas_task_pop_task(
+    queue_name: str = Query("", description="队列名字"),
+    cooldown_seconds: int = Query(30, description="冷却时间 默认30秒"),
+    db: AsyncSession = Depends(get_db),
+):
+    task = await VasTaskService.pop_vas_task(db, queue_name, 30)
+    return success(data=task)

+ 58 - 0
app/api/endpoints/webhook.py

@@ -0,0 +1,58 @@
+import stripe
+from app.core.logger import logger
+from app.core.config import settings
+from fastapi import APIRouter, Request, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.redis import get_redis_client
+from app.core.database import get_db
+from redis.asyncio import Redis
+from app.utils.response import success
+from app.schemas.common import ApiResponse
+from app.schemas.webhook import SMSHelperWebhookPayload
+from app.services.webhook_service import WebhookService
+
+public_router = APIRouter()
+protected_router = APIRouter()
+admin_required_router = APIRouter()
+
+
+@public_router.post("/webhook/smshelper", summary="双开助手Webhook", tags=["webhook"], response_model=ApiResponse)
+async def webhook_smshelper(
+    payload: SMSHelperWebhookPayload,
+    db: AsyncSession = Depends(get_db),
+    redis_client: Redis = Depends(get_redis_client)
+):
+    logger.info(f'smshelper webhook title={payload.title}, content={payload.content}')
+    if "微信支付" in payload.title:
+        res = await WebhookService.smshelper_payment_webhook(db, payload)
+    return success()
+
+
+@public_router.post("/webhook/stripe", summary="Stripe Webhook", tags=["webhook"], response_model=ApiResponse)
+async def webhook_stripe(
+    request: Request,
+    db: AsyncSession = Depends(get_db),
+    redis_client: Redis = Depends(get_redis_client)
+):
+    payload = await request.body()
+    sig_header = request.headers.get("stripe-signature")
+    
+    
+    # 3️⃣ 打调试日志(安全,不要打 secret)
+    logger.info("Stripe webhook received")
+    logger.info("Stripe-Signature: %s", sig_header)
+    logger.info("Payload bytes length: %s", len(payload))
+    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,
+    )
+    
+    event = stripe.Webhook.construct_event(
+        payload=payload,
+        sig_header=sig_header,
+        secret=settings.stripe_webhook_secret,
+    )
+    res = await WebhookService.stripe_payment_webhook(db, event)
+    return success()
+

+ 50 - 1397
app/api/router.py

@@ -1,95 +1,24 @@
-import time
-import uuid
-import json
-import requests
-import stripe
-from typing import List, Dict, Any, Optional
-from app.core.logger import logger
-from app.core.config import settings
-from fastapi import APIRouter, Request, Response, Query, Depends, Body, UploadFile, File
-from fastapi.responses import RedirectResponse
-from sqlalchemy.ext.asyncio import AsyncSession
-from app.utils.validation_utils import validate_user_inputs
-from app.core.redis import get_redis_client
-from app.core.database import get_db
-from app.core.auth import get_current_user
-from redis.asyncio import Redis
-
-from app.utils.response import success, fail
-from app.models.user import VasUser
-from app.models.order import VasOrder
-from app.models.schema import VasSchema
-from app.models.product import VasProduct
-from app.models.payment import VasPayment
-from app.schemas.common import ApiResponse, PageResponse
-from app.schemas.sms import ShortMessageDetail, SmsSendIn
-from app.schemas.configuration import ConfigurationCreate, ConfigurationUpdate, ConfigurationOut
-from app.schemas.email_authorizations import EmailContent, EmailAuthorizationCreate, EmailAuthorizationUpdate, EmailAuthorizationOut
-from app.schemas.emails import VasEmailCreate, VasEmailOut
-from app.schemas.task import TaskCreate, TaskOut, TaskUpdate
-from app.schemas.short_url import ShortUrlCreate, ShortUrlOut
-from app.schemas.http_session import HttpSessionCreate,HttpSessionOut
-from app.schemas.auth import SendBindCodeRequest, SendResetCodeRequest, BindEmailRequest, ResetPasswordRequest, LoginRequest, LoginData, AutoRegisterRequest, AutoRegisterData
-from app.schemas.user import VasUserCreate, VasUserUpdate, VasUserSetProfiles, VasUserOut
-from app.schemas.product import VasProductCreate, VasProductUpdate, VasProductOut
-from app.schemas.product_routing import VasProductRoutingCreate, VasProductRoutingOut
-from app.schemas.schema import VasSchemaCreate, VasSchemaUpdate, VasSchemaOut
-from app.schemas.order import VasOrderCreate, VasOrderAdjustPrice, VasOrderPatchUserInputs, VasOrderOut
-from app.schemas.payment import VasPaymentCreate, AdminUpdateStatusPayload, VasPaymentOut
-from app.schemas.payment_confirmation import VasPaymentConfirmationCreate, VasPaymentConfirmationUpdate, VasPaymentConfirmationOut
-from app.schemas.payment_qr import VasPaymentQrCreate, VasPaymentQrSetEnableIn, VasPaymentQrOut
-from app.schemas.payment_provider import VasPaymentProviderCreate, VasPaymentProviderUpdate, VasPaymentProviderOut
-from app.schemas.webhook import SMSHelperWebhookPayload
-from app.schemas.vas_task import VasTaskCreate, VasTaskUpdate, VasExpiringTaskItem, VasTaskOut
-from app.schemas.ticket import VasTicketCreate, VasTicketOut, VasTicketStatusUpdate, VasTicketMessageCreate, VasTicketMessageOut
-from app.schemas.slot_snapshot import SlotSnapshotCreate, SlotSnapshotOut, SlotOverviewOut
-from app.schemas.slot_refresh_status import RefreshBase, RefreshFail, RefreshStatusOut
-from app.schemas.telegram import TelegramIn, TelegramNoTokenIn
-from app.schemas.wechat import WechatIn, WechatNoTokenIn
-from app.schemas.whatsapp import WhatsappIn, WhatsappNoTokenIn
-from app.schemas.notification_outbox import NotificationOutboxCreate, NotificationOutboxUpdate, NotificationOutboxOut
-from app.schemas.resource import FileUploadOut
-from app.schemas.statistics import VasStatisticsOverviewOut
-from app.schemas.llm import ParseUserInputsPayload, ParseUserInputsOut
-from app.schemas.account import AccountOut, AccountCreate, AccountUpdate, GetNextAccountPayload
-from app.schemas.proxy_pool import ProxyCreate, ProxyUpdate, ProxyOut, GetNextIpPayload
-from app.schemas.order_event import VasOrderEventCreate, VasOrderEventOut
-from app.services.configuration_service import ConfigurationService
-from app.services.visametric_service import VisametricService
-from app.services.sms_service import save_short_message, query_short_message, send_sms
-from app.services.email_authorizations_service import EmailAuthorizationService
-from app.schemas.visa_free_config import VisaFreeConfigFetchRequest
-from app.services.visa_free_config_service import fetch_visa_free_config
-from app.services.emails_service import EmailsService
-from app.services.short_url_service import ShortUrlService
-from app.services.task_service import TaskService
-from app.services.seaweedfs_service import SeaweedFSService
-from app.services.http_session_service import HttpSessionService
-from app.services.fake_service import FakeService
-from app.services.auth_service import AuthService
-from app.services.user_service import UserService
-from app.services.product_service import ProductService
-from app.services.product_routing_service import ProductRoutingService
-from app.services.order_service import OrderService
-from app.services.schema_service import SchemaService
-from app.services.payment_service import PaymentService
-from app.services.payment_provider_service import PaymentProviderService
-from app.services.payment_qr_service import PaymentQrService
-from app.services.vas_task_service import VasTaskService
-from app.services.webhook_service import WebhookService
-from app.services.notification_service import NotificationService
-from app.services.ticket_service import TicketService
-from app.services.telegram_service import TelegramService
-from app.services.wechat_service import WechatService
-from app.services.whatsapp_service import WhatsappService
-from app.services.notification_outbox_service import NotificationOutboxService
-from app.services.slot_snapshot_service import SlotSnapshotService
-from app.services.statistics_service import StatisticsService
-from app.services.llm_service import LlmService
-from app.services.slot_refresh_status_service import SlotRefreshStatusService
-from app.services.account_service import AccountService
-from app.services.order_event_service import OrderEventService
-from app.services.proxy_service import ProxyService
+from fastapi import APIRouter
+
+from app.api.endpoints import (
+    account,
+    auth,
+    common,
+    config,
+    email,
+    notification,
+    order,
+    payment,
+    product,
+    proxy,
+    slot,
+    sms,
+    task,
+    ticket,
+    user,
+    vas_task,
+    webhook,
+)
 
 # 公共路由
 public_router = APIRouter()
@@ -98,1308 +27,32 @@ protected_router = APIRouter()
 # 管理员级别路由
 admin_required_router = APIRouter()
 
-@admin_required_router.get("/ping", summary="心跳检测", tags=["测试接口"])
-async def ping():
-    return {"message": "pong"}
-
-@admin_required_router.get("/sms/upload", summary="上报短信", tags=["短信接口"], response_model=ApiResponse[ShortMessageDetail])
-async def sms_upload(
-    phone: str = Query(..., description="手机号"),
-    message: str = Query(..., description="短信内容"),
-    max_ttl: int = Query(300, description="短信保存时间(秒)"),
-    redis_client: Redis = Depends(get_redis_client)
-):
-    """
-    保存短信到 Redis
-    """
-    received_at = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
-    msg = await save_short_message(redis_client, phone, message, received_at, max_ttl)
-    return success(data=msg)
-
-@admin_required_router.get("/sms/download", summary="读取短信", tags=["短信接口"], response_model=ApiResponse[List[ShortMessageDetail]])
-async def sms_download(
-    phone: str = Query(..., description="手机号"),
-    keyword: str = Query('', description="短信内容关键字"),
-    sent_at: str = Query('', description="筛选时间(可选)"),
-    redis_client: Redis = Depends(get_redis_client)
-):
-    """
-    查询短信(支持关键字和时间过滤)
-    """
-    obj = await query_short_message(redis_client, phone, keyword or None, sent_at or None)
-    return success(data=obj)
-
-
-@admin_required_router.post("/sms/send", summary="发送短信", tags=["短信接口"], response_model=ApiResponse[str])
-async def sms_send(
-    payload: SmsSendIn,
-):
-    res = await send_sms(
-        send_to=payload.send_to,
-        sender=payload.sender,
-        content=payload.content,
-    )
-    return success(data=res)
-
-@admin_required_router.post("/visametric/update_pnr", summary="VISAMETRIC 读取PNR", tags=["Visametric专用"], response_model=ApiResponse[VasTaskOut])
-async def visametric_update_pnr(
-    task_id: int,
-    db: AsyncSession = Depends(get_db)
-):
-    obj = await VisametricService.update_pnr(db, task_id)
-    return success(data=obj)
-
-@admin_required_router.post("/visametric/cancel_appointment", summary="VISAMETRIC 取消预约", tags=["Visametric专用"], response_model=ApiResponse)
-async def visametric_cancel_appointment(
-    task_id: int,
-    db: AsyncSession = Depends(get_db),
-    redis_client: Redis = Depends(get_redis_client)
-):
-    await VisametricService.cancel_appointment(db, redis_client, task_id)
-    return success()
-
-@admin_required_router.post("/dynamic-configurations", summary="创建动态配置", tags=["动态配置"], response_model=ApiResponse[ConfigurationOut])
-async def dynamic_config_create(config_in: ConfigurationCreate, db: AsyncSession = Depends(get_db)):
-    obj = await ConfigurationService.create(db, config_in)
-    return success(data=obj)
-
-@admin_required_router.get("/dynamic-configurations/all", summary="读取所有动态配置", tags=["动态配置"], response_model=ApiResponse[List[ConfigurationOut]])
-async def dynamic_config_get_all(db: AsyncSession = Depends(get_db)):
-    obj = await ConfigurationService.get_all(db)
-    return success(data=obj)
-    
-@admin_required_router.get("/dynamic-configurations/key/{config_key}", summary="根据Key读取动态配置", tags=["动态配置"], response_model=ApiResponse[ConfigurationOut])
-async def dynamic_config_get_by_key(config_key: str, db: AsyncSession = Depends(get_db)):
-    config = await ConfigurationService.get_by_key(db, config_key)
-    return success(data=config)
-
-
-@admin_required_router.put("/dynamic-configurations/key/{config_key}", summary="根据Key更新动态配置", tags=["动态配置"], response_model=ApiResponse[ConfigurationOut])
-async def dynamic_config_update_by_key(config_key: str, config_in: ConfigurationUpdate, db: AsyncSession = Depends(get_db)):
-    config = await ConfigurationService.update_by_key(db, config_key, config_in)
-    return success(data=config)
-
-
-@admin_required_router.delete("/dynamic-configurations/key/{config_key}", summary="根据Key删除动态配置", tags=["动态配置"], response_model=ApiResponse[ConfigurationOut])
-async def dynamic_config_delete_by_key(config_key: str, db: AsyncSession = Depends(get_db)):
-    config = await ConfigurationService.delete_by_key(db, config_key)
-    return success(data=config)
-
-@admin_required_router.post("/http-session", summary="创建http session", tags=["会话管理"],response_model=ApiResponse[HttpSessionOut])
-async def http_session_create(
-    data: HttpSessionCreate,
-    db: AsyncSession = Depends(get_db)
-):
-    logger.info(f"[Create HttpSession] sid={data.session_id}")
-    obj = await HttpSessionService.create(db, data)
-    return success(data=obj)
-
-@admin_required_router.get("/http-session", summary="读取http session", tags=["会话管理"],response_model=ApiResponse[HttpSessionOut])
-async def http_session_get_by_sid(
-    session_id: str = Query(...),
-    db: AsyncSession = Depends(get_db)
-):
-    logger.info(f"[Get HttpSession] sid={session_id}")
-    obj = await HttpSessionService.get_by_sid(db, session_id)
-    return success(data=obj)
-
-
-@admin_required_router.get("/email-authorizations", summary="查询所有内部邮箱", tags=["邮箱接口"], response_model=ApiResponse[List[EmailAuthorizationOut]])
-async def email_authorizations_get(db: AsyncSession = Depends(get_db)):
-    obj = await EmailAuthorizationService.get_all(db)
-    return success(data=obj)
-
-
-@admin_required_router.post("/email-authorizations", summary="创建内部邮箱", tags=["邮箱接口"], response_model=ApiResponse[EmailAuthorizationOut])
-async def email_authorizations_create(data: EmailAuthorizationCreate, db: AsyncSession = Depends(get_db)):
-    obj = await EmailAuthorizationService.create(db, data)
-    return success(data=obj)
-
-@admin_required_router.get("/email-authorizations/{id}", summary="通过id查询内部邮箱", tags=["邮箱接口"], response_model=ApiResponse[EmailAuthorizationOut])
-async def email_authorizations_get_by_id(id: int, db: AsyncSession = Depends(get_db)):
-    email_auth = await EmailAuthorizationService.get_by_id(db, id)
-    return success(data=email_auth)
-
-
-@admin_required_router.put("/email-authorizations/{id}", summary="通过id更新内部邮箱", tags=["邮箱接口"], response_model=ApiResponse[EmailAuthorizationOut])
-async def email_authorizations_update_by_id(id: int, data: EmailAuthorizationUpdate, db: AsyncSession = Depends(get_db)):
-    updated = await EmailAuthorizationService.update(db, id, data)
-    return success(data=updated)
-
-
-@admin_required_router.delete("/email-authorizations/{id}", summary="通过id删除内部邮箱", tags=["邮箱接口"], response_model=ApiResponse[EmailAuthorizationOut])
-async def email_authorizations_delete_by_id(id: int, db: AsyncSession = Depends(get_db)):
-    deleted = await EmailAuthorizationService.delete(db, id)
-    return success(data=deleted)
-
-
-@admin_required_router.get("/email-authorizations/email/{email}", summary="通过邮箱地址查询内部邮箱", tags=["邮箱接口"], response_model=ApiResponse[EmailAuthorizationOut])
-async def email_authorizations_get_by_email(email: str, db: AsyncSession = Depends(get_db)):
-    email_auth = await EmailAuthorizationService.get_by_email(db, email)
-    return success(data=email_auth)
-
-@admin_required_router.post("/email-authorizations/fetch", summary="读取邮件, 仅限文本内容", tags=["邮箱接口"], response_model=ApiResponse[EmailContent])
-async def email_authorizations_fetch_email(
-    email: str = Query(..., description="收件邮箱账号, 格式: xxx@xxx.xxx"),
-    sender: str = Query(..., description="发件人邮箱账号或者名字"),
-    recipient: str = Query(..., description="收件人账号或者名字"),
-    subjectKeywords: str = Query("", description="邮件主题关键词, 支持多个关键词, 用逗号隔开"),
-    bodyKeywords: str = Query("", description="邮件内容关键词, 支持多个关键词, 用逗号隔开"),
-    sentDate: str = Query(..., description="发件日期, UTC时间, 格式: yyyy-mm-dd hh:mm:ss"),
-    expiry: int = Query(300, description="邮件有效期, 单位秒, 从sentDate 开始算起"),
-    onlyText: bool = Query(True, description="是否纯文本"),
-    db: AsyncSession = Depends(get_db)
-):
-    auth = await EmailAuthorizationService.get_by_email(db, email)
-    print(auth)
-    result = await EmailAuthorizationService.fetch_email_authorizations(
-        auth,
-        sender=sender,
-        recipient=recipient,
-        subject_keywords=subjectKeywords,
-        body_keywords=bodyKeywords,
-        sent_date=sentDate,
-        expiry=expiry,
-        only_text=onlyText
-    )
-    return success(data={"body": result})
-
-@admin_required_router.post("/email-authorizations/fetch-top", summary="从最近的几封邮件读取目标邮件,仅限文本内容, 性能会更好, 邮件多时有可能漏读", tags=["邮箱接口"], response_model=ApiResponse[EmailContent])
-async def email_authorizations_fetch_email_from_topn(
-    email: str = Query(..., description="收件邮箱账号, 格式: xxx@xxx.xxx"),
-    sender: str = Query(..., description="发件人邮箱账号或者名字"),
-    recipient: str = Query(..., description="收件人账号或者名字"),
-    subjectKeywords: str = Query("", description="邮件主题关键词, 支持多个关键词, 用逗号隔开"),
-    bodyKeywords: str = Query("", description="邮件内容关键词, 支持多个关键词, 用逗号隔开"),
-    top: int = Query(10, description="指定从最近几封邮件读取"),
-    onlyText: bool = Query(True, description="是否纯文本"),
-    db: AsyncSession = Depends(get_db)
-):
-    auth = await EmailAuthorizationService.get_by_email(db, email)
-    result = await EmailAuthorizationService.fetch_email_authorizations_from_top_n(
-        auth,
-        sender=sender,
-        recipient=recipient,
-        subject_keywords=subjectKeywords,
-        body_keywords=bodyKeywords,
-        top=top,
-        only_text=onlyText
-    )
-    return success(data={"body": result})
-
-@admin_required_router.post("/email-authorizations/forward", summary="转发邮件", tags=["邮箱接口"], response_model=ApiResponse[EmailContent])
-async def email_authorizations_forward_email(
-    emailAccount: str = Query(..., description="收件邮箱账号, 格式: xxx@xxx.xxx"),
-    forwardTo: str = Query(..., description="转发到哪个邮箱地址, 格式: xxx@xxx.xxx"),
-    sender: str = Query(..., description="发件人邮箱账号或者名字"),
-    recipient: str = Query(..., description="收件人账号或者名字"),
-    subjectKeywords: str = Query("", description="邮件主题关键词, 支持多个关键词, 用逗号隔开"),
-    bodyKeywords: str = Query("", description="邮件内容关键词, 支持多个关键词, 用逗号隔开"),
-    db: AsyncSession = Depends(get_db)
-):
-    auth = await EmailAuthorizationService.get_by_email(db, emailAccount)
-    result = await EmailAuthorizationService.forward_first_matching_email(
-        auth,
-        forward_to = forwardTo,
-        sender = sender,
-        recipient = recipient,
-        subject_keywords = subjectKeywords,
-        body_keywords = bodyKeywords
-    )
-    return success(data={"body": result})
-
-@admin_required_router.post("/email-authorizations/forward2", summary="转发邮件(新)", tags=["邮箱接口"], response_model=ApiResponse[EmailContent])
-async def email_authorizations_forward_email2(
-    emailAccount: str = Query(..., description="收件邮箱账号, 格式: xxx@xxx.xxx"),
-    forwardTo: str = Query(..., description="转发到哪个邮箱地址, 格式: xxx@xxx.xxx"),
-    sender: str = Query(..., description="发件人邮箱账号或者名字"),
-    recipient: str = Query(..., description="收件人账号或者名字"),
-    subjectKeywords: str = Query("", description="邮件主题关键词, 支持多个关键词, 用逗号隔开"),
-    bodyKeywords: str = Query("", description="邮件内容关键词, 支持多个关键词, 用逗号隔开"),
-    db: AsyncSession = Depends(get_db)
-):
-    auth = await EmailAuthorizationService.get_by_email(db, emailAccount)
-    result = await EmailAuthorizationService.forward_first_matching_email2(
-        db,
-        auth,
-        forward_to = forwardTo,
-        sender = sender,
-        recipient = recipient,
-        subject_keywords = subjectKeywords,
-        body_keywords = bodyKeywords
-    )
-    return success(data={"body": result})
-
-@admin_required_router.post("/email-authorizations/sendmail", summary="发送邮件", tags=["邮箱接口"], response_model=ApiResponse[EmailContent])
-async def email_authorizations_send_email(
-    emailAccount: str = Query(..., description="发件账号, 格式: xxx@xxx.xxx"),
-    sendTo: str = Query(..., description="收件人邮箱账号"),
-    subject: str = Query(..., description="邮件主题"),
-    contentType: str = Query("text", description="内容格式,支持 text 和 html"),
-    content: EmailContent = Body("", description="邮件内容"),
-    db: AsyncSession = Depends(get_db)
-):
-    auth = await EmailAuthorizationService.get_by_email(db, emailAccount)
-    result = await EmailAuthorizationService.send_email(
-        auth,
-        send_to = sendTo,
-        subject = subject,
-        content_type = contentType,
-        content = content.body
-    )
-    return success(data={"body": result})
-
-@admin_required_router.post("/email-authorizations/sendmail-bulk", summary="群发送邮件", tags=["邮箱接口"], response_model=ApiResponse[EmailContent])
-async def email_authorizations_send_email_bulk(
-    emailAccount: str = Query(..., description="收件邮箱账号, 格式: xxx@xxx.xxx"),
-    sendTo: str = Query(..., description="收件人邮箱账号,多个用逗号隔开"),
-    subject: str = Query(..., description="邮件主题"),
-    contentType: str = Query("text", description="内容格式,支持 text 和 html"),
-    content: EmailContent = Body(..., description="邮件内容"),
-    db: AsyncSession = Depends(get_db)
-):
-    auth = await EmailAuthorizationService.get_by_email(db, emailAccount)
-    result = await EmailAuthorizationService.send_email_bulk(
-        auth,
-        send_to = sendTo,
-        subject = subject,
-        content_type = contentType,
-        content = content.body
-    )
-    return success(data={"body": result})
-
-@admin_required_router.post("/emails/write", summary="写入邮件", tags=["邮箱接口"], response_model=ApiResponse[VasEmailOut])
-async def emails_write(
-    payload: VasEmailCreate,
-    db: AsyncSession = Depends(get_db)
-):
-    rec = await EmailsService.create(db, payload)
-    return success(data=rec)
-
-@admin_required_router.get("/emails/max_uid", summary="获取最大邮件UID", tags=["邮箱接口"], response_model=ApiResponse[int])
-async def emails_get_max_uid(
-    db: AsyncSession = Depends(get_db)
-):
-    uid = await EmailsService.get_max_uid(db)
-    return success(data=uid)
-
-@admin_required_router.get("/account/list_all", summary="分页查询账号", tags=["账号管理"], response_model=ApiResponse[PageResponse[AccountOut]])
-async def account_list(
-    page: int = Query(0, description="第几页"),
-    size: int = Query(10, description="分页大小"),
-    keyword: str = Query("", description="查询条件"),
-    db: AsyncSession = Depends(get_db)
-):
-    obj = await AccountService.list_all(db, page, size, keyword)
-    return success(data=obj)
-
-@admin_required_router.post("/account/next", summary="获取下一个账号", tags=["账号管理"], response_model=ApiResponse[AccountOut])
-async def account_next(
-    payload: GetNextAccountPayload, 
-    db: AsyncSession = Depends(get_db)
-):
-    account = await AccountService.get_next_account(db, payload.pool_name, payload.account_cd)
-    return success(data=account)
-
-@admin_required_router.post("/account/add", summary="新增一个账号", tags=["账号管理"], response_model=ApiResponse[AccountOut])
-async def account_add(
-    payload: AccountCreate,
-    db: AsyncSession = Depends(get_db)
-):
-    account = await AccountService.add_account(db, payload)
-    return success(data=account)
-
-@admin_required_router.delete("/account/delete", summary="删除账号", tags=["账号管理"], response_model=ApiResponse)
-async def account_remove(
-    account_id: int,
-    db: AsyncSession = Depends(get_db)
-):
-    await AccountService.remove_account(db, account_id)
-    return success()
-
-@admin_required_router.put("/account/update", summary="更新账号", tags=["账号管理"], response_model=ApiResponse[AccountOut])
-async def account_update(
-    account_id: int,
-    payload: AccountUpdate,
-    db: AsyncSession = Depends(get_db)
-):
-    account = await AccountService.update_account(db, account_id, payload)
-    return success(data=account)
-   
-
-@admin_required_router.post("/proxy/create", summary="创建代理", tags=["代理管理"], response_model=ApiResponse[ProxyOut])
-async def proxy_create(
-    payload: ProxyCreate,
-    db: AsyncSession = Depends(get_db)
-):
-    proxy = await ProxyService.create_proxy(db, payload)
-    return success(data=proxy)
-
-@admin_required_router.put("/proxy/update", summary="更新代理", tags=["代理管理"], response_model=ApiResponse[ProxyOut])
-async def proxy_update(
-    proxy_id: int,
-    payload: ProxyUpdate,
-    db: AsyncSession = Depends(get_db)
-):
-    proxy = await ProxyService.update_proxy(db, proxy_id, payload)
-    return success(data=proxy)
-
-@admin_required_router.delete("/proxy/delete", summary="删除代理", tags=["代理管理"], response_model=ApiResponse)
-async def proxy_remove(
-    proxy_id: int,
-    db: AsyncSession = Depends(get_db)
-):
-    await ProxyService.remove_proxy(db, proxy_id)
-    return success()
-
-@admin_required_router.get("/proxy/list_all", summary="查询代理", tags=["代理管理"], response_model=ApiResponse[PageResponse[ProxyOut]])
-async def proxy_list(
-    page: int = Query(0, description="第几页"),
-    size: int = Query(10, description="分页大小"),
-    keyword: str = Query("", description="查询条件"),
-    db: AsyncSession = Depends(get_db)
-):
-    obj = await ProxyService.list_proxy(db, page, size, keyword)
-    return success(data=obj)
-
-@admin_required_router.post("/proxy/next-ip", summary="获取下一个ip", tags=["代理管理"], response_model=ApiResponse[ProxyOut])
-async def proxy_next_ip_get(
-    payload: GetNextIpPayload,
-    db: AsyncSession = Depends(get_db)
-):
-    proxy = await ProxyService.get_next_ip(db, payload.pools, payload.proxy_cd)
-    return success(data=proxy)
-
-@public_router.post("/resource/upload_file", summary="上传文件", tags=["文件管理"], response_model=ApiResponse[FileUploadOut])
-async def resource_upload_file(file: UploadFile = File(...)):
-    result = await SeaweedFSService.upload(file)
-    return success(data=result)
-
-@public_router.get("/resource/download_file", summary="下载文件", tags=["文件管理"])
-async def resource_get_file(fid: str):
-    data = await SeaweedFSService.get(fid)
-    content, mime = data
-    return Response(content=content, media_type=mime)
-
-@admin_required_router.post("/s/generate", summary="生成短链接地址<压缩地址长度>", tags=["Short URL"], response_model=ApiResponse[ShortUrlOut])
-async def short_url_generate(
-    data: ShortUrlCreate,
-    db: AsyncSession = Depends(get_db),
-):
-    """生成短链接"""
-    record = await ShortUrlService.create_short_url(db, data.long_url)
-    return success(data=record)
-
-@public_router.get("/s/{short_key}", summary="访问短链接地址<自动重定向到真实链接地址>", tags=["Short URL"])
-async def short_url_request(short_key: str, db: AsyncSession = Depends(get_db)):
-    """访问短链接自动重定向"""
-    long_url = await ShortUrlService.get_long_url(db, short_key)
-    return RedirectResponse(url=long_url, status_code=302)
-
-@admin_required_router.post("/tasks", summary="创建任务", tags=["任务管理接口"], response_model=ApiResponse[TaskOut])
-async def task_create(data: TaskCreate, db: AsyncSession = Depends(get_db)):
-    """创建任务"""
-    task = await TaskService.create(db, data)
-    return success(data=task)
-
-@admin_required_router.get("/tasks/{task_id:int}", summary="根据taskId读取任务状态", tags=["任务管理接口"], response_model=ApiResponse[TaskOut])
-async def task_get_by_id(task_id: int, db: AsyncSession = Depends(get_db)):
-    """获取任务"""
-    task = await TaskService.get_by_id(db, task_id)
-    return success(data=task)
-
-@admin_required_router.get("/tasks/pending", summary="获取等待执行的任务", tags=["任务管理接口"], response_model=ApiResponse[List[TaskOut]])
-async def task_get_pending(
-    page: int = Query(0, description="第几页"),
-    size: int = Query(10, description="分页大小"),
-    command: str = Query(..., description="任务类型"),
-    db: AsyncSession = Depends(get_db),
-):
-    """分页获取等待执行的任务"""
-    obj = await TaskService.get_pending(db, command, page, size)
-    return success(data=obj)
-
-@admin_required_router.put("/tasks/{task_id}", summary="根据taskId更新任务状态", tags=["任务管理接口"], response_model=ApiResponse[TaskOut])
-async def task_update_by_id(task_id: int, data: TaskUpdate, db: AsyncSession = Depends(get_db)):
-    """更新任务状态或结果"""
-    updated = await TaskService.update(db, task_id, data)
-    return success(data=updated)
-
-@admin_required_router.get("/task/pop", summary="任务出队(pop)", tags=["任务管理接口"], response_model=ApiResponse[TaskOut])
-async def task_pop_task(
-    queue_name: str,
-    db: AsyncSession = Depends(get_db),
-):
-    task = await TaskService.pop_task(db, queue_name)
-    return success(data=task)
-
-@admin_required_router.post("/tg/send_message", summary="推送电报消息", tags=["消息推送接口"], response_model=ApiResponse)
-async def tg_send_message(
-    payload: TelegramIn
-):
-    await TelegramService.push_text(payload)
-    return success()
-
-@admin_required_router.post("/tg/send_message_no_token", summary="推送电报消息(无需token)", tags=["消息推送接口"], response_model=ApiResponse)
-async def tg_send_message_no_token(
-    payload: TelegramNoTokenIn
-):
-    await TelegramService.push_text_no_token(payload)
-    return success()
-
-@admin_required_router.post("/wechat/send", summary="推送微信文本消息", tags=["消息推送接口"], response_model=ApiResponse)
-async def wechat_send(
-    payload: WechatIn
-):
-    await WechatService.push_text(payload.api_token, payload.message)
-    return success()
-
-@admin_required_router.post("/wechat/send_no_token", summary="推送微信文本消息(无需token)", tags=["消息推送接口"], response_model=ApiResponse)
-async def wechat_send_no_token(
-    payload: WechatNoTokenIn
-):
-    await WechatService.push_text_no_token(payload.message)
-    return success()
-
-@admin_required_router.post("/wechat/send_markdown_no_token", summary="推送微信Markdown消息(无需token)", tags=["消息推送接口"], response_model=ApiResponse)
-async def wechat_send_markdown_no_token(
-    payload: WechatNoTokenIn
-):
-    await WechatService.push_markdown_no_token(payload.message)
-    return success()
-
-@admin_required_router.post("/wechat/send_markdown", summary="推送微信Markdown消息", tags=["消息推送接口"], response_model=ApiResponse)
-async def wechat_send_markdown(
-    payload: WechatIn
-):
-    await WechatService.push_markdown(payload.api_token, payload.message)
-    return success()
-
-@admin_required_router.post("/whatsapp/send", summary="推送WhatsApp消息", tags=["消息推送接口"], response_model=ApiResponse)
-async def whatsapp_send(
-    payload: WhatsappIn
-):
-    api_base_url = payload.api_base_url or "https://waha.text.skin"
-    await WhatsappService.send_text(
-        api_base_url=api_base_url,
-        session=payload.session,
-        chat_id=payload.chat_id,
-        message=payload.message,
-        api_key=payload.api_key,
-    )
-    return success()
-
-@admin_required_router.post("/whatsapp/send_no_token", summary="推送WhatsApp消息(无需token)", tags=["消息推送接口"], response_model=ApiResponse)
-async def whatsapp_send_no_token(
-    payload: WhatsappNoTokenIn
-):
-    await WhatsappService.send_text_no_token(
-        chat_id=payload.chat_id,
-        message=payload.message,
-    )
-    return success()
-
-
-@admin_required_router.post("/notification/outbox/create", summary="创建通知消息", tags=["消息推送接口"], response_model=ApiResponse[NotificationOutboxOut])
-async def notification_outbox_create(
-    payload: NotificationOutboxCreate,
-    db: AsyncSession = Depends(get_db)
-):
-    obj = await NotificationOutboxService.create(db, payload)
-    return success(data=obj)
-
-@admin_required_router.post("/notification/outbox/update", summary="更新通知消息", tags=["消息推送接口"], response_model=ApiResponse[NotificationOutboxOut])
-async def notification_outbox_update(
-    id: int,
-    payload: NotificationOutboxUpdate,
-    db: AsyncSession = Depends(get_db)
-):
-    obj = await NotificationOutboxService.update(db, id, payload)
-    return success(data=obj)
-
-@admin_required_router.get("/notification/outbox/detail", summary="获取通知详情", tags=["消息推送接口"], response_model=ApiResponse[NotificationOutboxOut])
-async def notification_outbox_detail(
-    id: int,
-    db: AsyncSession = Depends(get_db)
-):
-    obj = await NotificationOutboxService.get(db, id)
-    return success(data=obj)
-
-@admin_required_router.get("/notification/outbox/list", summary="分页查询通知列表", tags=["消息推送接口"], response_model=ApiResponse[PageResponse[NotificationOutboxOut]])
-async def notification_outbox_list(
-    status: str = Query("", description="状态"),
-    channel: str = Query("", description="渠道"),
-    priority: int = Query(0, description="优先级"),
-    msg_id: str = Query("", description="消息ID"),
-    page: int = Query(1, description="第几页"),
-    size: int = Query(20, description="分页大小"),
-    db: AsyncSession = Depends(get_db)
-):
-    obj = await NotificationOutboxService.list(db, status, channel, priority, msg_id, page, size)
-    return success(data=obj)
-
-@admin_required_router.get("/fake/orders", summary="生成虚假的订单信息", tags=["数据生成"], response_model=ApiResponse[List[VasOrderOut]])
-async def fake_generate_fake_orders(
-    num: int = Query(1, description="生成几个数据"),
-    product_id = Query(1, description="商品Id"),
-    db: AsyncSession = Depends(get_db),
-    current_user: VasUser = Depends(get_current_user),
-):
-    orders = await FakeService.generate_orders(db, num, product_id, current_user)
-    return success(data=orders)
-
-@public_router.get("/slots/latest", summary="查询最近的slot", tags=["Slot数据"], response_model=ApiResponse[SlotSnapshotOut])
-async def slots_latest_get(
-    country: str = Query("", description="目的国家"),
-    city: str = Query("", description="递交城市"),
-    visa_type: str = Query("", description="签证类型"),
-    db: AsyncSession = Depends(get_db)
-):
-    res = await SlotSnapshotService.latest_for(db, country, city, visa_type)
-    return success(data=res)
-
-@public_router.get("/slots/overview", summary="查询最近的slot", tags=["Slot数据"], response_model=ApiResponse[List[SlotOverviewOut]])
-async def slots_latest_get(
-    city: str = Query("", description="递交城市"),
-    db: AsyncSession = Depends(get_db)
-):
-    res = await SlotSnapshotService.get_slot_overview(db, city)
-    return success(data=res)
-
-@admin_required_router.post("/slots/report", summary="上报最近的slot", tags=["Slot数据"], response_model=ApiResponse[SlotSnapshotOut])
-async def slots_report(
-    payload: SlotSnapshotCreate,
-    db: AsyncSession = Depends(get_db),
-    redis_client: Redis = Depends(get_redis_client)
-):
-    res = await SlotSnapshotService.report(db, redis_client, payload)
-    return success(data=res)
-
-@admin_required_router.post("/slot_refresh/start", summary="刷新slot开始", tags=["Slot Monitor 监控"], response_model=ApiResponse[RefreshStatusOut])
-async def slot_refresh_start(data: RefreshBase, db: AsyncSession = Depends(get_db)
-):
-    data = await SlotRefreshStatusService.refresh_start(db, data)
-    return success(data=data)
-
-@admin_required_router.post("/slot_refresh/success", summary="刷新slot成功", tags=["Slot Monitor 监控"], response_model=ApiResponse[RefreshStatusOut])
-async def  slot_refresh_success(data: RefreshBase, db: AsyncSession = Depends(get_db)
-):
-    data = await SlotRefreshStatusService.refresh_success(db, data)
-    return success(data=data)
-
-@admin_required_router.post("/slot_refresh/fail", summary="刷新slot失败", tags=["Slot Monitor 监控"], response_model=ApiResponse[RefreshStatusOut])
-async def slot_refresh_fail(data: RefreshFail,db: AsyncSession = Depends(get_db)
-):
-    data = await SlotRefreshStatusService.refresh_fail(db, data)
-    return success(data=data)
-
-@admin_required_router.get("/slot_refresh/status", summary="查询刷新纪录", tags=["Slot Monitor 监控"], response_model=ApiResponse[List[RefreshStatusOut]])
-async def slot_refresh_status(db: AsyncSession = Depends(get_db)):
-    data = await SlotRefreshStatusService.list_all(db)
-    return success(data=data)
-
-@public_router.post("/webhook/smshelper", summary="双开助手Webhook", tags=["webhook"], response_model=ApiResponse)
-async def webhook_smshelper(
-    payload: SMSHelperWebhookPayload,
-    db: AsyncSession = Depends(get_db),
-    redis_client: Redis = Depends(get_redis_client)
-):
-    logger.info(f'smshelper webhook title={payload.title}, content={payload.content}')
-    if "微信支付" in payload.title:
-        res = await WebhookService.smshelper_payment_webhook(db, payload)
-    return success()
-
-@public_router.post("/webhook/stripe", summary="Stripe Webhook", tags=["webhook"], response_model=ApiResponse)
-async def webhook_stripe(
-    request: Request,
-    db: AsyncSession = Depends(get_db),
-    redis_client: Redis = Depends(get_redis_client)
-):
-    payload = await request.body()
-    sig_header = request.headers.get("stripe-signature")
-    
-    
-    # 3️⃣ 打调试日志(安全,不要打 secret)
-    logger.info("Stripe webhook received")
-    logger.info("Stripe-Signature: %s", sig_header)
-    logger.info("Payload bytes length: %s", len(payload))
-    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,
-    )
-    
-    event = stripe.Webhook.construct_event(
-        payload=payload,
-        sig_header=sig_header,
-        secret=settings.stripe_webhook_secret,
-    )
-    res = await WebhookService.stripe_payment_webhook(db, event)
-    return success()
-
-@public_router.post("/auth/auto-register", summary="自动注册", tags=["用户管理"], response_model=ApiResponse[AutoRegisterData])
-async def vas_auto_register(
-    payload: AutoRegisterRequest,
-    request: Request,
-    db: AsyncSession = Depends(get_db)
-):
-    user_agent = request.headers.get("user-agent", "unknown")
-    client_host = request.client.host
-    x_forwarded_for = request.headers.get("x-forwarded-for")
-    if x_forwarded_for:
-        client_ip = x_forwarded_for.split(",")[0].strip()
-    else:
-        client_ip = client_host
-    res = await AuthService.auto_register(db, payload, client_ip, user_agent)
-    return success(data=res)
-
-@public_router.post("/auth/send-bind-code", summary="发送邮箱注册码 绑定邮箱用", tags=["用户管理"], response_model=ApiResponse)
-async def vas_send_bind_code(
-    payload: SendBindCodeRequest,
-    current_user: VasUser = Depends(get_current_user),
-    db: AsyncSession = Depends(get_db),
-    redis_client: Redis = Depends(get_redis_client)
-):
-    await AuthService.send_bind_code(db, payload, current_user, redis_client)
-    return success(message="verify email sent, please check your inbox")
-
-@public_router.post("/auth/send-reset-code", summary="发送邮箱注册码 重置密码用", tags=["用户管理"], response_model=ApiResponse)
-async def vas_send_reset_code(
-    payload: SendResetCodeRequest,
-    db: AsyncSession = Depends(get_db),
-    redis_client: Redis = Depends(get_redis_client)
-):
-    await AuthService.send_reset_code(db, payload, redis_client)
-    return success(message="verify email sent, please check your inbox")
-
-@protected_router.post("/auth/bind-email", summary="绑定邮箱", tags=["用户管理"], response_model=ApiResponse[LoginData])
-async def vas_bind_email(
-    payload: BindEmailRequest,
-    request: Request,
-    current_user: VasUser = Depends(get_current_user),
-    db: AsyncSession = Depends(get_db),
-    redis_client: Redis = Depends(get_redis_client)
-):
-    user_agent = request.headers.get("user-agent", "unknown")
-    client_host = request.client.host
-    x_forwarded_for = request.headers.get("x-forwarded-for")
-    if x_forwarded_for:
-        client_ip = x_forwarded_for.split(",")[0].strip()
-    else:
-        client_ip = client_host
-    res = await AuthService.bind_email(db, payload, current_user, redis_client, client_ip, user_agent)
-    return success(data=res)
-
-@public_router.post("/auth/reset-password", summary="重置密码", tags=["用户管理"], response_model=ApiResponse)
-async def vas_reset_password(
-    payload: ResetPasswordRequest,
-    db: AsyncSession = Depends(get_db)
-):
-    res = await AuthService.reset_password(db, payload)
-    return success(data=res)
-
-@public_router.post("/auth/login", summary="邮箱登录", tags=["用户管理"], response_model=ApiResponse[LoginData])
-async def vas_login(
-    payload: LoginRequest,
-    request: Request,
-    db: AsyncSession = Depends(get_db)
-):
-    user_agent = request.headers.get("user-agent", "unknown")
-    client_host = request.client.host
-    x_forwarded_for = request.headers.get("x-forwarded-for")
-    if x_forwarded_for:
-        client_ip = x_forwarded_for.split(",")[0].strip()
-    else:
-        client_ip = client_host
-    res = await AuthService.login(db, payload, client_ip, user_agent)
-    return success(data=res)
-
-@admin_required_router.get("/user/list_all", summary="获取所有用户", tags=["用户管理"], response_model=ApiResponse[PageResponse[VasUserOut]])
-async def vas_user_list_all(
-    page: int = Query(0, description="第几页"),
-    size: int = Query(10, description="分页大小"),
-    keyword: str = Query("", description="查询条件"),
-    db: AsyncSession = Depends(get_db)
-):
-    users = await UserService.list_all(db, page, size, keyword)
-    return success(data=users)
-
-@admin_required_router.get("/user/detail", summary="获取用户信息", tags=["用户管理"], response_model=ApiResponse[VasUserOut])
-async def vas_user_get_detail(
-    user_id: str,
-    db: AsyncSession = Depends(get_db)
-):
-    user = await UserService.get(db, user_id)
-    return success(data=user)
-
-@admin_required_router.post("/user/update", summary="更新用户信息", tags=["用户管理"], response_model=ApiResponse[VasUserOut])
-async def vas_user_update(
-    uid: str,
-    payload: VasUserUpdate,
-    db: AsyncSession = Depends(get_db)
-):
-    updated = await UserService.update(db, uid, payload)
-    return success(data=updated)
-
-@protected_router.post("/user/set_profiles", summary="更新用户信息", tags=["用户管理"], response_model=ApiResponse[VasUserOut])
-async def vas_user_update(
-    payload: VasUserSetProfiles,
-    current_user: VasUser = Depends(get_current_user),
-    db: AsyncSession = Depends(get_db)
-):
-    updated = await UserService.set_profiles(db, current_user, payload)
-    return success(data=updated)
-
-@admin_required_router.get("/vas/statistics/overview", summary="系统概览", tags=["textskin"], response_model=ApiResponse[VasStatisticsOverviewOut])
-async def vas_statistics_overview(
-    db: AsyncSession = Depends(get_db)
-):
-    overview = await StatisticsService.overview(db)
-    return success(data=overview)
-
-@admin_required_router.post("/vas/product/create", summary="创建商品", tags=["textskin"], response_model=ApiResponse[VasProductOut])
-async def vas_product_create(
-    payload: VasProductCreate,
-    db: AsyncSession = Depends(get_db)
-):
-    created_product = await ProductService.create(db, payload)
-    return success(data=created_product)
-
-@admin_required_router.post("/vas/product/update", summary="更新商品", tags=["textskin"], response_model=ApiResponse[VasProductOut])
-async def vas_product_update(
-    id: int,
-    payload: VasProductUpdate,
-    db: AsyncSession = Depends(get_db)
-):
-    product = await ProductService.update(db, id, payload)
-    return success(data=product)
-
-@public_router.get("/vas/product/list-enable", summary="获取商品列表", tags=["textskin"], response_model=ApiResponse[PageResponse[VasProductOut]])
-async def vas_product_list(
-    country: str = Query("", description="目的国家"),
-    visa_type: str = Query("", description="签证类型"),
-    page: int = Query(0, description="第几页"),
-    size: int = Query(10, description="分页大小"),
-    keyword: str = Query("", description="查询条件"),
-    db: AsyncSession = Depends(get_db)
-):
-    products = await ProductService.list_enable_product(db, country, visa_type, page, size, keyword)
-    return success(data=products)
-
-@admin_required_router.get("/vas/product/list", summary="获取商品列表", tags=["textskin"], response_model=ApiResponse[PageResponse[VasProductOut]])
-async def vas_product_list(
-    country: str = Query("", description="目的国家"),
-    visa_type: str = Query("", description="签证类型"),
-    page: int = Query(0, description="第几页"),
-    size: int = Query(10, description="分页大小"),
-    keyword: str = Query("", description="查询条件"),
-    db: AsyncSession = Depends(get_db)
-):
-    products = await ProductService.list_product(db, country, visa_type, page, size, keyword)
-    return success(data=products)
-
-@public_router.get("/vas/product/detail", summary="获取商品列表", tags=["textskin"], response_model=ApiResponse[VasProductOut])
-async def vas_product_get_by_id(
-    product_id: int,
-    db: AsyncSession = Depends(get_db)
-):
-    products = await ProductService.get(db, product_id)
-    return success(data=products)
-
-@admin_required_router.post("/vas/product_routing/create", summary="创建商品路由列表", tags=["textskin"], response_model=ApiResponse[VasProductRoutingOut])
-async def vas_product_routing_create(
-    payload: VasProductRoutingCreate,
-    db: AsyncSession = Depends(get_db)
-):
-    payload = await ProductRoutingService.create(db, payload)
-    return success(data=payload)
-
-@admin_required_router.delete("/vas/product_routing/delete", summary="删除商品路由列表", tags=["textskin"], response_model=ApiResponse)
-async def vas_product_routing_date(
-    id: int,
-    db: AsyncSession = Depends(get_db)
-):
-    await ProductRoutingService.delete(db, id)
-    return success()
-
-@admin_required_router.get("/vas/product_routing/list", summary="获取商品路由列表", tags=["textskin"], response_model=ApiResponse[List[VasProductRoutingOut]])
-async def vas_product_routing_list_by_product(
-    product_id: int,
-    db: AsyncSession = Depends(get_db)
-):
-    product_routings = await ProductRoutingService.list_by_product(db, product_id)
-    return success(data=product_routings)
-
-@admin_required_router.post("/vas/llm/data_parsing", summary="llm数据解析", tags=["textskin"], response_model=ApiResponse[ParseUserInputsOut])
-async def vas_llm_data_parsing(
-    payload: ParseUserInputsPayload,
-    db: AsyncSession = Depends(get_db)
-):
-    out = await LlmService.handle_parse(db, payload)
-    return success(data=out)
-
-@public_router.get("/vas/schema/detail", summary="获取schema", tags=["textskin"], response_model=ApiResponse[VasSchemaOut])
-async def vas_schema_get(
-    schema_id: int,
-    db: AsyncSession = Depends(get_db)
-):
-    schema = await SchemaService.get(db, schema_id)
-    return success(data=schema)
-
-@admin_required_router.post("/vas/schema/create", summary="新增schema", tags=["textskin"], response_model=ApiResponse[VasSchemaOut])
-async def vas_schema_create(
-    payload: VasSchemaCreate,
-    db: AsyncSession = Depends(get_db)
-):
-    schema = await SchemaService.create(db, payload)
-    return success(data=schema)
-
-@admin_required_router.post("/vas/schema/update", summary="更新schema", tags=["textskin"], response_model=ApiResponse[VasSchemaOut])
-async def vas_schema_update(
-    id: int,
-    payload: VasSchemaUpdate,
-    db: AsyncSession = Depends(get_db)
-):
-    schema = await SchemaService.update(db, id, payload)
-    return success(data=schema)
-
-@admin_required_router.delete("/vas/schema/delete", summary="删除schema", tags=["textskin"], response_model=ApiResponse)
-async def vas_schema_delete(
-    id: int,
-    db: AsyncSession = Depends(get_db)
-):
-    await SchemaService.delete(db, id)
-    return success()
-
-@admin_required_router.get("/vas/schema/list", summary="获取schema列表", tags=["textskin"], response_model=ApiResponse[List[VasSchemaOut]])
-async def vas_schema_list(
-    db: AsyncSession = Depends(get_db)
-):
-    schemas = await SchemaService.list_all(db)
-    return success(data=schemas)
-
-@protected_router.post("/vas/order/create", summary="创建订单", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
-async def vas_order_create(
-    payload: VasOrderCreate,
-    current_user: VasUser = Depends(get_current_user),
-    db: AsyncSession = Depends(get_db),
-    redis_client: Redis = Depends(get_redis_client)
-):
-    product = await ProductService.get(db, payload.product_id)
-    # ① 获取产品绑定的 schema
-    schema = await SchemaService.get(db, product.schema_id)
-    # ② 校验 user_inputs
-    validate_user_inputs(
-        schema_json=schema.schema_json,
-        user_inputs=payload.user_inputs,
-    )
-    created_order = await OrderService.create(db, payload, product, current_user, redis_client)
-    return success(data=created_order)
-
-@admin_required_router.post("/vas/order/create_by_admin", summary="管理员创建订单", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
-async def vas_order_create_by_admin(
-    payload: VasOrderCreate,
-    current_user: VasUser = Depends(get_current_user),
-    db: AsyncSession = Depends(get_db)
-):
-    product = await ProductService.get(db, payload.product_id)
-    # ① 获取产品绑定的 schema
-    schema = await SchemaService.get(db, product.schema_id)
-    # ② 校验 user_inputs
-    validate_user_inputs(
-        schema_json=schema.schema_json,
-        user_inputs=payload.user_inputs,
-    )
-    created_order = await OrderService.create_by_admin(db, payload, product, current_user)
-    return success(data=created_order)
-
-@admin_required_router.post("/vas/order/adjust-price", summary="管理员调整订单价格", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
-async def vas_order_adjust_price(
-    order_id: str,
-    payload: VasOrderAdjustPrice,
-    db: AsyncSession = Depends(get_db),
-    current_user: VasUser = Depends(get_current_user)
-):
-    order = await OrderService.adjust_order_price(db, order_id, payload)
-    return success(data=order)
-
-@admin_required_router.get("/vas/order/detail", summary="查询订单", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
-async def vas_order_create(
-    order_id: str,
-    db: AsyncSession = Depends(get_db),
-):
-    order = await OrderService.get(db, order_id)
-    return success(data=order)
-
-@admin_required_router.post("/vas/order/patch_user_inputs", summary="更新订单的用户信息", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
-async def vas_order_patch_user_inputs(
-    order_id: str,
-    payload: VasOrderPatchUserInputs,
-    db: AsyncSession = Depends(get_db),
-):
-    order = await OrderService.patch_user_inputs(db, order_id, payload)
-    return success(data=order)
-
-@protected_router.get("/vas/order/list_by_user", summary="查看所有订单", tags=["textskin"], response_model=ApiResponse[PageResponse[VasOrderOut]])
-async def vas_order_list_by_user(
-    page: int = Query(0, description="第几页"),
-    size: int = Query(10, description="分页大小"),
-    keyword: str = Query("", description="查询条件"),
-    current_user: VasUser = Depends(get_current_user),
-    db: AsyncSession = Depends(get_db)
-):
-    orders = await OrderService.list_by_user(db, current_user.id, page, size, keyword)
-    return success(data=orders)
-
-@protected_router.get("/vas/order/list_all", summary="查看所有订单", tags=["textskin"], response_model=ApiResponse[PageResponse[VasOrderOut]])
-async def vas_order_list_all(
-    page: int = Query(0, description="第几页"),
-    size: int = Query(10, description="分页大小"),
-    keyword: str = Query("", description="查询条件"),
-    db: AsyncSession = Depends(get_db)
-):
-    orders = await OrderService.list_all(db, page, size, keyword)
-    return success(data=orders)
-
-@admin_required_router.post("/vas/order/cancel", summary="取消订单", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
-async def vas_order_cancel(
-    order_id: str,
-    current_user: VasUser = Depends(get_current_user),
-    db: AsyncSession = Depends(get_db),
-    redis_client: Redis = Depends(get_redis_client)
-):
-    cancelled_order = await OrderService.cancel(db, order_id)
-    return success(data=cancelled_order)
-
-@admin_required_router.post("/vas/order-event/create", summary="创建订单事件", tags=["textskin"], response_model=ApiResponse[VasOrderEventOut])
-async def vas_order_event_create(
-    event_data: VasOrderEventCreate,
-    db: AsyncSession = Depends(get_db)
-):
-    obj = await OrderEventService.create(db, event_data)
-    return success(data=obj)
-
-@protected_router.get("/vas/order-event/list", summary="获取订单的所有事件", tags=["textskin"], response_model=ApiResponse[List[VasOrderEventOut]])
-async def vas_list_order_events_by_order(
-    order_id: str,
-    db: AsyncSession = Depends(get_db)
-):
-    events = await OrderEventService.get_by_order_id(db, order_id)
-    return success(data=events)
-
-@protected_router.get("/vas/payment_provider/list_enabled", summary="获取支付方式", tags=["textskin"], response_model=ApiResponse[List[VasPaymentProviderOut]])
-async def vas_payment_provider_simple_get(
-    db: AsyncSession = Depends(get_db)
-):
-    providers = await PaymentProviderService.list_enabled(db)
-    return success(data=providers)
-
-@admin_required_router.get("/vas/payment_provider/list_all", summary="获取支付方式", tags=["textskin"], response_model=ApiResponse[List[VasPaymentProviderOut]])
-async def vas_payment_provider_list_all(
-    db: AsyncSession = Depends(get_db)
-):
-    providers = await PaymentProviderService.list_all(db)
-    return success(data=providers)
-
-@admin_required_router.post("/vas/payment_provider/create", summary="新增支付服务提供商", tags=["textskin"], response_model=ApiResponse[VasPaymentProviderOut])
-async def vas_payment_provider_create(
-    payload: VasPaymentProviderCreate,
-    db: AsyncSession = Depends(get_db)
-):
-    provider = await PaymentProviderService.create(db, payload)
-    return success(data=provider)
-
-@admin_required_router.post("/vas/payment_provider/update", summary="更新支付服务提供商", tags=["textskin"], response_model=ApiResponse[VasPaymentProviderOut])
-async def vas_payment_provider_update(
-    id: int,
-    payload: VasPaymentProviderUpdate,
-    db: AsyncSession = Depends(get_db)
-):
-    provider = await PaymentProviderService.update(db, id, payload)
-    return success(data=provider)
-
-@admin_required_router.delete("/vas/payment_provider/delete", summary="删除支付服务提供商", tags=["textskin"], response_model=ApiResponse)
-async def vas_payment_provider_delete(
-    id: int,
-    db: AsyncSession = Depends(get_db)
-):
-    await PaymentProviderService.delete(db, id)
-    return success()
-
-@protected_router.post("/vas/payment/create", summary="创建支付", tags=["textskin"], response_model=ApiResponse[VasPaymentOut])
-async def vas_payment_create(
-    payload: VasPaymentCreate,
-    db: AsyncSession = Depends(get_db),
-    redis_client: Redis = Depends(get_redis_client)
-):
-    res = await PaymentService.create_payment(db, payload, redis_client)
-    return success(data=res)
-
-@protected_router.get("/vas/payment/detail", summary="获取支付详情", tags=["textskin"], response_model=ApiResponse[VasPaymentOut])
-async def vas_payment_create(
-    payment_id: int,
-    db: AsyncSession = Depends(get_db),
-):
-    res = await PaymentService.get_by_id(db, payment_id)
-    return success(data=res)
-
-@admin_required_router.post("/vas/payment/confirm_by_admin", summary="管理员确认支付", tags=["textskin"], response_model=ApiResponse[VasPaymentConfirmationOut])
-async def vas_payment_confirm_by_admin(
-    id: int,
-    payload: VasPaymentConfirmationUpdate,
-    current_user: VasUser = Depends(get_current_user),
-    db: AsyncSession = Depends(get_db)
-):
-    res = await PaymentService.confirm_by_admin(db, id, payload, current_user)
-    return success(data=res)
-
-@admin_required_router.post("/vas/payment/admin_update_status", summary="管理员更新支付状态", tags=["textskin"], response_model=ApiResponse[VasPaymentOut])
-async def vas_payment_admin_update_status(
-    payment_id: int,
-    payload: AdminUpdateStatusPayload,
-    db: AsyncSession = Depends(get_db)
-):
-    res = await PaymentService.admin_update_status(db, payment_id, payload)
-    return success(data=res)
-
-@protected_router.post("/vas/payment/confirm_by_user", summary="用户确认支付", tags=["textskin"], response_model=ApiResponse[VasPaymentConfirmationOut])
-async def vas_payment_confirm_by_user(
-    payload: VasPaymentConfirmationCreate,
-    current_user: VasUser = Depends(get_current_user),
-    db: AsyncSession = Depends(get_db)
-):
-    res = await PaymentService.confirm_by_user(db, payload, current_user)
-    return success(data=res)
-
-@admin_required_router.post("/vas/payment_confirmation/list_all", summary="查询所有待确认支付", tags=["textskin"], response_model=ApiResponse[PageResponse[VasPaymentConfirmationOut]])
-async def vas_payment_confirm_list(
-    page: int = Query(0, description="第几页"),
-    size: int = Query(10, description="分页大小"),
-    keyword: str = Query("", description="查询条件"),
-    db: AsyncSession = Depends(get_db)
-):
-    res = await PaymentService.list_payment_confirmation(db, keyword, page, size)
-    return success(data=res)
-
-@protected_router.get("/vas/payment/list_by_order", summary="获取某个订单下的所有payment记录", tags=["textskin"], response_model=ApiResponse[List[VasPaymentOut]])
-async def vas_payment_list_by_order(
-    order_id: str,
-    db: AsyncSession = Depends(get_db)
-):
-    payments = await PaymentService.list_by_order(db, order_id)
-    return success(data=payments)
-
-@admin_required_router.post("/vas/payment_qr/create", summary="新增收款码", tags=["textskin"], response_model=ApiResponse[VasPaymentQrOut])
-async def vas_payment_qr_create(payload: VasPaymentQrCreate, db: AsyncSession = Depends(get_db)):
-    qr = await PaymentQrService.create(db, payload)
-    return success(data=qr)
-
-@protected_router.get("/vas/payment_qr/list_by_provider", summary="获取某个服务商的所有付款码", tags=["textskin"], response_model=ApiResponse[List[VasPaymentQrOut]])
-async def vas_payment_qr_list_qrcode_by_provider(provider_id: int, db: AsyncSession = Depends(get_db)):
-    qr = await PaymentQrService.list_by_provider(db, provider_id)
-    return success(data=qr)
-    
-@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)
-    return success(data=qr)
-
-@admin_required_router.post("/vas/payment_qr/set_enable", summary="修改QRCode", tags=["textskin"], response_model=ApiResponse[VasPaymentQrOut])
-async def vas_payment_qr_update(
-    id: int,
-    payload: VasPaymentQrSetEnableIn,
-    db: AsyncSession = Depends(get_db)
-):
-    qr = await PaymentQrService.set_enable(db, id, payload)
-    return success(data=qr)
-
-@admin_required_router.delete("/vas/payment_qr/delete", summary="删除QRCode", tags=["textskin"], response_model=ApiResponse)
-async def vas_payment_qr_update(
-    id: int,
-    db: AsyncSession = Depends(get_db)
-):
-    await PaymentQrService.delete(db, id)
-    return success()
-
-@admin_required_router.get("/vas/task/list", summary="获取待执行的任务", tags=["textskin"], response_model=ApiResponse[PageResponse[VasTaskOut]])
-async def vas_task_list(
-    page: int = Query(0, description="第几页"),
-    size: int = Query(10, description="分页大小"),
-    keyword: str = Query("", description="查询条件"),
-    status: str = Query("", description="task 自定义索引"),
-    routing_key: str = Query("", description="task 自定义索引"),
-    script_version: str = Query("", description="脚本版本, 用来向后兼容"),
-    db: AsyncSession = Depends(get_db)
-):
-    tasks = await VasTaskService.list_task(db, status, routing_key, script_version, keyword, page, size)
-    return success(data=tasks)
-
-@admin_required_router.get("/vas/task/expiring", summary="获取即将过期的任务列表", tags=["textskin"], response_model=ApiResponse[List[VasExpiringTaskItem]])
-async def vas_task_get_expiring_tasks(
-    days: int = 3,
-    db: AsyncSession = Depends(get_db)
-):
-    """获取即将过期的任务列表"""
-    tasks = await VasTaskService.get_expiring_tasks(db, threshold_days=days)
-    return success(data=tasks)
-
-@admin_required_router.post("/vas/task/update", summary="更新任务数据", tags=["textskin"], response_model=ApiResponse[VasTaskOut])
-async def vas_task_update(
-    id: int,
-    payload: VasTaskUpdate,
-    db: AsyncSession = Depends(get_db)
-):
-    task = await VasTaskService.update(db, id, payload)
-    return success(data=task)
-
-@admin_required_router.get("/vas/task/get_by_order", summary="根据订单查找任务", tags=["textskin"], response_model=ApiResponse[List[VasTaskOut]])
-async def vas_task_query_by_order(
-    order_id: str = Query(..., description="订单编号"),
-    script_version: str = Query("", description="脚本版本, 用来向后兼容"),
-    db: AsyncSession = Depends(get_db)
-):
-    tasks = await VasTaskService.get_task_by_order_id(db, order_id)
-    return success(data=tasks)
-
-@admin_required_router.post("/vas/task/pause", summary="暂停任务", tags=["textskin"], response_model=ApiResponse[VasTaskOut])
-async def vas_task_pause(task_id:int, db: AsyncSession = Depends(get_db)):
-    obj = await VasTaskService.pause(db, task_id)
-    return success(data=obj)
-
-@admin_required_router.get("/vas/task/detail", summary="根据taskid查找任务", tags=["textskin"], response_model=ApiResponse[VasTaskOut])
-async def vas_task_query_by_id(
-    task_id: int = Query(..., description="任务Id"),
-    db: AsyncSession = Depends(get_db)
-):
-    task = await VasTaskService.get_task_by_id(db, task_id)
-    return success(data=task)
-
-@admin_required_router.post("/vas/task/return_to_queue", summary="重新进入等候状态", tags=["textskin"], response_model=ApiResponse[VasTaskOut])
-async def vas_task_return_to_queue(task_id:int, db: AsyncSession = Depends(get_db)):
-    obj = await VasTaskService.return_to_queue(db, task_id)
-    return success(data=obj)
-
-@admin_required_router.post("/vas/task/manual_confirm", summary="设置任务完成", tags=["textskin"], response_model=ApiResponse[VasTaskOut])
-async def vas_task_manual_confirm(
-    task_id:int,
-    db: AsyncSession = Depends(get_db),
-    redis_client: Redis = Depends(get_redis_client)
-):
-    obj = await VasTaskService.manual_confirm(db, task_id, redis_client)
-    return success(data=obj)
-
-@admin_required_router.get("/vas/task/pop", summary="任务出队(pop)", tags=["textskin"], response_model=ApiResponse[VasTaskOut])
-async def vas_task_pop_task(
-    queue_name: str = Query("", description="队列名字"),
-    cooldown_seconds: int = Query(30, description="冷却时间 默认30秒"),
-    db: AsyncSession = Depends(get_db),
-):
-    task = await VasTaskService.pop_vas_task(db, queue_name, 30)
-    return success(data=task)
-
-@protected_router.post("/vas/ticket/create", summary="创建工单", tags=["textskin"], response_model=ApiResponse[VasTicketOut])
-async def vas_ticket_create(
-    data:VasTicketCreate,
-    current_user: VasUser = Depends(get_current_user),
-    db: AsyncSession = Depends(get_db),
-    redis_client: Redis = Depends(get_redis_client)
-):
-    obj = await TicketService.create(db, data, current_user, redis_client)
-    return success(data=obj)
-
-@protected_router.get("/vas/ticket/list_by_user", summary="查看工单", tags=["textskin"], response_model=ApiResponse[PageResponse[VasTicketOut]])
-async def vas_ticket_list_by_user(
-    page: int = Query(0, description="第几页"),
-    size: int = Query(10, description="分页大小"),
-    keyword: str = Query("", description="查询条件"),
-    current_user: VasUser = Depends(get_current_user),
-    db: AsyncSession = Depends(get_db)
-):
-    tickets = await TicketService.list_by_user(db, current_user.id, page, size, keyword)
-    return success(data=tickets)
-
-@admin_required_router.get("/vas/ticket/list_all", summary="查看工单", tags=["textskin"], response_model=ApiResponse[PageResponse[VasTicketOut]])
-async def vas_ticket_list_all(
-    page: int = Query(0, description="第几页"),
-    size: int = Query(10, description="分页大小"),
-    keyword: str = Query("", description="查询条件"),
-    db: AsyncSession = Depends(get_db)
-):
-    tickets = await TicketService.list_all(db, page, size, keyword)
-    return success(data=tickets)
-
-@admin_required_router.post("/vas/tickets/status", summary="管理员更新工单状态", tags=["textskin"], response_model=ApiResponse[VasTicketOut])
-async def update_ticket_status(
-    ticket_id: int,
-    payload: VasTicketStatusUpdate,
-    db: AsyncSession = Depends(get_db),
-    user=Depends(get_current_user)
-):
-    res = await TicketService.update_status(
-        db=db,
-        ticket_id=ticket_id,
-        status=payload.status,
-        comment=payload.comment,
-        admin_id=user.id
-    )
-    return success(data=res)
-    
-@protected_router.post("/vas/tickets/send_message", summary="发送工单消息", tags=["textskin"], response_model=ApiResponse[VasTicketMessageOut])
-async def create_ticket_message(
-    ticket_id: int,
-    payload: VasTicketMessageCreate,
-    db: AsyncSession = Depends(get_db),
-    user=Depends(get_current_user)
-):
-    res = await TicketService.add_message(
-        db=db,
-        ticket_id=ticket_id,
-        sender_type=user.role,
-        sender_id=user.id,
-        content=payload.content,
-        attachments=payload.attachments
-    )
-    return success(data=res)
-    
-@protected_router.get("/vas/tickets/fetch_message", summary="分页获取工单会话", tags=["textskin"], response_model=ApiResponse[PageResponse[VasTicketMessageOut]])
-async def get_ticket_messages(
-    ticket_id: int,
-    page: int = 1,
-    size: int = 20,
-    db: AsyncSession = Depends(get_db)
-):
-    msgs = await TicketService.list_messages(
-        db=db,
-        ticket_id=ticket_id,
-        page=page,
-        size=size
-    )
-    return success(data=msgs)
-
-@protected_router.post("/visa/free-config/fetch", summary="获取签证中心 free_config 配置", tags=["Visa Config"], response_model=ApiResponse[Dict[str, Any]])
-async def fetch_visa_free_config_post(payload: VisaFreeConfigFetchRequest = Body(...)):
-    res = fetch_visa_free_config(
-        provider=payload.provider,
-        origin=payload.origin,
-        target=payload.target,
-        visa_type=payload.visa_type,
-        vac=payload.vac
-    )
-    return success(data=res)
-
-@protected_router.get("/visa/free-config/fetch", summary="获取签证中心 free_config 配置(GET)", tags=["Visa Config"], response_model=ApiResponse[Dict[str, Any]])
-async def fetch_visa_free_config_get(
-    provider: str = Query(...),
-    origin: str = Query(...),
-    target: str = Query(...),
-    visa_type: str = Query(...),
-    vac: Optional[str] = Query(None)
-):
-    res = fetch_visa_free_config(
-        provider=provider,
-        origin=origin,
-        target=target,
-        visa_type=visa_type,
-        vac=vac
-    )
-    return success(data=res)
+# 模块列表
+_modules = [
+    account,
+    auth,
+    common,
+    config,
+    email,
+    notification,
+    order,
+    payment,
+    product,
+    proxy,
+    slot,
+    sms,
+    task,
+    ticket,
+    user,
+    vas_task,
+    webhook,
+]
+
+# 注册所有子模块路由
+for _mod in _modules:
+    if hasattr(_mod, "public_router") and _mod.public_router.routes:
+        public_router.include_router(_mod.public_router)
+    if hasattr(_mod, "protected_router") and _mod.protected_router.routes:
+        protected_router.include_router(_mod.protected_router)
+    if hasattr(_mod, "admin_required_router") and _mod.admin_required_router.routes:
+        admin_required_router.include_router(_mod.admin_required_router)

+ 18 - 1
app/core/config.py

@@ -20,7 +20,6 @@ class Settings(BaseSettings):
     # -----------------------
     # Security / API Keys
     # -----------------------
-    openai_api_key: str
     stripe_api_key: str
     stripe_webhook_secret: str
     telegram_api_token: str = Field("", description="Telegram bot API token")
@@ -29,13 +28,31 @@ class Settings(BaseSettings):
     whatsapp_api_key: str = Field("", description="Whatsapp API key")
     whatsapp_session: str = Field("default", description="Whatsapp session")
 
+    # -----------------------
+    # Storage (SeaweedFS) & Network
+    # -----------------------
+    api_base_url: str = Field("https://api.text.skin", description="Public API base URL for resource links")
+    seaweedfs_master_url: str = Field("http://seaweedfs-master:9333", description="SeaweedFS Master URL")
+    seaweedfs_volume_override_host: str = Field("", description="Optional host/IP to override SeaweedFS Volume address for cross-network access")
+
+    # -----------------------
+    # LLM Configuration (OpenAI-compatible)
+    # -----------------------
+    llm_api_key: str = Field("", description="LLM API Key (defaults to openai_api_key)")
+    llm_base_url: str = Field("https://dashscope.aliyuncs.com/compatible-mode/v1", description="OpenAI-compatible Base URL")
+    llm_model: str = Field("qwen-plus", description="Default model name, e.g., qwen-plus, gpt-4o, deepseek-chat")
+    llm_temperature: float = Field(0.0, description="LLM sampling temperature")
+    llm_timeout_seconds: int = Field(30, description="LLM request timeout in seconds")
+
     model_config = SettingsConfigDict(
         env_file=".env",
         env_file_encoding="utf-8",
         case_sensitive=False,
+        extra="ignore",
     )
 
 
+
 @lru_cache
 def get_settings() -> Settings:
     """

+ 55 - 18
app/core/logger.py

@@ -4,44 +4,81 @@ from logging.handlers import TimedRotatingFileHandler
 
 
 # ===============================
-# 基本配置
+# 日志存储目录
 # ===============================
-LOG_DIR = os.path.join(os.path.dirname(__file__), "../../logs")
+LOG_DIR = os.getenv(
+    "LOG_DIR",
+    os.path.abspath(os.path.join(os.path.dirname(__file__), "../../logs"))
+)
 os.makedirs(LOG_DIR, exist_ok=True)
 
-LOG_FILE = os.path.join(LOG_DIR, "app.log")
+APP_LOG_FILE = os.path.join(LOG_DIR, "app.log")
+ERROR_LOG_FILE = os.path.join(LOG_DIR, "error.log")
+ACCESS_LOG_FILE = os.path.join(LOG_DIR, "access.log")
 
 
 # ===============================
 # 日志格式
 # ===============================
-LOG_FORMAT = "[%(asctime)s] [%(levelname)s] [%(name)s] [%(filename)s:%(lineno)d] - %(message)s"
+LOG_FORMAT = "[%(asctime)s] [%(levelname)s] [pid:%(process)d] [%(name)s] [%(filename)s:%(lineno)d] - %(message)s"
+ACCESS_LOG_FORMAT = "[%(asctime)s] [ACCESS] [pid:%(process)d] - %(message)s"
 DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
 
+formatter = logging.Formatter(LOG_FORMAT, DATE_FORMAT)
+access_formatter = logging.Formatter(ACCESS_LOG_FORMAT, DATE_FORMAT)
+
 
 # ===============================
-# 主 logger 实例
+# 主业务 Logger ("app")
 # ===============================
 logger = logging.getLogger("app")
-logger.setLevel(logging.INFO)  # 可改为 DEBUG
+logger.setLevel(logging.INFO)
 
-# 防止重复添加 handler
 if not logger.handlers:
-    # 控制台输出
+    # 1. 控制台输出
     console_handler = logging.StreamHandler()
     console_handler.setLevel(logging.INFO)
-    console_handler.setFormatter(logging.Formatter(LOG_FORMAT, DATE_FORMAT))
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
 
-    # 文件输出(每天切割)
-    file_handler = TimedRotatingFileHandler(
-        LOG_FILE, when="midnight", interval=1, backupCount=7, encoding="utf-8"
+    # 2. app.log 业务全量日志(按天滚动,保留 14 天)
+    app_file_handler = TimedRotatingFileHandler(
+        APP_LOG_FILE, when="midnight", interval=1, backupCount=14, encoding="utf-8"
     )
-    file_handler.setLevel(logging.INFO)
-    file_handler.setFormatter(logging.Formatter(LOG_FORMAT, DATE_FORMAT))
+    app_file_handler.setLevel(logging.INFO)
+    app_file_handler.setFormatter(formatter)
+    logger.addHandler(app_file_handler)
 
-    # 添加到 logger
-    logger.addHandler(console_handler)
-    logger.addHandler(file_handler)
+    # 3. error.log 错误日志专用通道(仅记录 ERROR 及以上级别,保留 30 天)
+    error_file_handler = TimedRotatingFileHandler(
+        ERROR_LOG_FILE, when="midnight", interval=1, backupCount=30, encoding="utf-8"
+    )
+    error_file_handler.setLevel(logging.ERROR)
+    error_file_handler.setFormatter(formatter)
+    logger.addHandler(error_file_handler)
 
-    # 避免重复日志
     logger.propagate = False
+
+
+# ===============================
+# 访问日志 Logger ("access")
+# ===============================
+access_logger = logging.getLogger("access")
+access_logger.setLevel(logging.INFO)
+
+if not access_logger.handlers:
+    # 控制台
+    access_console_handler = logging.StreamHandler()
+    access_console_handler.setLevel(logging.INFO)
+    access_console_handler.setFormatter(access_formatter)
+    access_logger.addHandler(access_console_handler)
+
+    # access.log 访问日志(按天滚动,保留 14 天)
+    access_file_handler = TimedRotatingFileHandler(
+        ACCESS_LOG_FILE, when="midnight", interval=1, backupCount=14, encoding="utf-8"
+    )
+    access_file_handler.setLevel(logging.INFO)
+    access_file_handler.setFormatter(access_formatter)
+    access_logger.addHandler(access_file_handler)
+
+    access_logger.propagate = False

+ 46 - 2
app/main.py

@@ -6,13 +6,14 @@ from fastapi.openapi.utils import get_openapi
 from fastapi.exceptions import RequestValidationError
 from starlette.exceptions import HTTPException as StarletteHTTPException
 
+import time
 from app.api import router
 from app.core.database import AsyncSessionLocal
 from app.core.auth import RoleLevel, require_min_role
 from app.core.config import settings
 from app.core.payment import init_stripe
 from app.core.biz_exception import BizException
-from app.core.logger import logger
+from app.core.logger import logger, access_logger
 
 
 @asynccontextmanager
@@ -26,11 +27,49 @@ async def lifespan(app: FastAPI):
 app = FastAPI(title=settings.app_name, lifespan=lifespan)
 
 
+# -----------------------
+# Access Log & Performance Middleware
+# -----------------------
+@app.middleware("http")
+async def access_log_middleware(request: Request, call_next):
+    start_time = time.perf_counter()
+    client_ip = request.client.host if request.client else "unknown"
+    method = request.method
+    path = request.url.path
+    query = request.url.query
+    full_path = f"{path}?{query}" if query else path
+
+    try:
+        response = await call_next(request)
+        process_time_ms = (time.perf_counter() - start_time) * 1000.0
+        status_code = response.status_code
+
+        if process_time_ms > 1000:
+            logger.warning(
+                f"⚠️ [SLOW REQUEST] {method} {full_path} | ip={client_ip} | status={status_code} | duration={process_time_ms:.2f}ms"
+            )
+
+        access_logger.info(
+            f"{method} {full_path} | ip={client_ip} | status={status_code} | duration={process_time_ms:.2f}ms"
+        )
+        return response
+    except Exception as exc:
+        process_time_ms = (time.perf_counter() - start_time) * 1000.0
+        logger.error(
+            f"❌ [REQUEST ERROR] {method} {full_path} | ip={client_ip} | duration={process_time_ms:.2f}ms | error: {exc}",
+            exc_info=True,
+        )
+        raise exc
+
+
 # -----------------------
 # Exception Handlers
 # -----------------------
 @app.exception_handler(BizException)
 async def biz_exception_handler(request: Request, exc: BizException):
+    logger.warning(
+        f"⚠️ [BIZ ERROR] {request.method} {request.url.path} | code={exc.code} | msg={exc.message}"
+    )
     return JSONResponse(
         status_code=exc.http_status,
         content={
@@ -43,7 +82,11 @@ async def biz_exception_handler(request: Request, exc: BizException):
 
 @app.exception_handler(Exception)
 async def unhandled_exception_handler(request: Request, exc: Exception):
-    logger.error("Unhandled exception", exc_info=exc)
+    client_ip = request.client.host if request.client else "unknown"
+    logger.error(
+        f"💥 [500 UNHANDLED EXCEPTION] {request.method} {request.url.path} | ip={client_ip}",
+        exc_info=exc,
+    )
 
     return JSONResponse(
         status_code=500,
@@ -54,6 +97,7 @@ async def unhandled_exception_handler(request: Request, exc: Exception):
         },
     )
 
+
 @app.exception_handler(RequestValidationError)
 async def validation_exception_handler(request: Request, exc: RequestValidationError):
     """

+ 1 - 0
app/schemas/llm.py

@@ -6,6 +6,7 @@ from datetime import datetime
 class ParseUserInputsPayload(BaseModel):
     input_raw_str: str
     schema_id: int
+    model: Optional[str] = None
     
 class ParseUserInputsOut(BaseModel):
     parsed_obj: Optional[Dict[str, Any]]

+ 19 - 0
app/services/auth_service.py

@@ -11,6 +11,7 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 from redis.asyncio import Redis
 
+from app.core.logger import logger
 from app.core.biz_exception import (
     NotFoundError,
     PermissionDeniedError,
@@ -30,6 +31,7 @@ from app.schemas.auth import (
 from app.services.notification_service import NotificationService
 
 
+
 def _random_password(length: int = 16) -> str:
     return "".join(
         random.choices(
@@ -92,6 +94,7 @@ class AuthService:
         await db.commit()
         await db.refresh(user)
 
+        logger.info(f"👤 [AUTH] Auto-registered guest user: id={uid} nickname={user.nickname} ip={ip or 'unknown'}")
         return {"user": user, "token": token}
 
     # =========================
@@ -113,6 +116,7 @@ class AuthService:
         db.add(record)
         await db.commit()
 
+        logger.info(f"📧 [AUTH] Sent bind code to {payload.email} for user={auth_user.id}")
         await NotificationService.post_message(
             db=db,
             channel="email",
@@ -143,6 +147,7 @@ class AuthService:
         user = (await db.execute(stmt)).scalar_one_or_none()
 
         if not user:
+            logger.warning(f"⚠️ [AUTH] Password reset requested for non-existent or unverified email: {payload.email}")
             raise BizLogicError("User not exist")
 
         expiration_time = datetime.utcnow() + timedelta(minutes=10)
@@ -154,6 +159,7 @@ class AuthService:
         db.add(record)
         await db.commit()
 
+        logger.info(f"📧 [AUTH] Sent reset password code to {payload.email} for user={user.id}")
         await NotificationService.post_message(
             db=db,
             channel="email",
@@ -186,6 +192,7 @@ class AuthService:
             VasUser.email_verified == 1,
         )
         if (await db.execute(stmt)).scalar_one_or_none():
+            logger.warning(f"⚠️ [AUTH] Bind email failed: {payload.email} is already bound")
             raise BizLogicError("Email already bound")
 
         # 校验验证码
@@ -195,9 +202,11 @@ class AuthService:
         )
         record = (await db.execute(stmt)).scalar_one_or_none()
         if not record:
+            logger.warning(f"⚠️ [AUTH] Invalid bind token for email {payload.email}")
             raise BizLogicError("Token invalid")
 
         if record.expire_at < datetime.utcnow():
+            logger.warning(f"⚠️ [AUTH] Expired bind token for email {payload.email}")
             raise BizLogicError("Token expired")
 
         user = await db.get(VasUser, auth_user.id)
@@ -225,6 +234,8 @@ class AuthService:
 
         await db.commit()
         await db.refresh(user)
+
+        logger.info(f"✅ [AUTH] Email bound successfully: user={user.id} email={user.email} ip={ip or 'unknown'}")
         
         await NotificationService.post_message(
             db=db,
@@ -257,6 +268,7 @@ class AuthService:
         )
         user = (await db.execute(stmt)).scalar_one_or_none()
         if not user:
+            logger.warning(f"⚠️ [AUTH] Password reset attempt on non-existent email: {payload.email}")
             raise BizLogicError("User not exist")
 
         stmt = select(VasVerificationToken).where(
@@ -265,9 +277,11 @@ class AuthService:
         )
         record = (await db.execute(stmt)).scalar_one_or_none()
         if not record:
+            logger.warning(f"⚠️ [AUTH] Password reset invalid token for {payload.email}")
             raise BizLogicError("Token invalid")
 
         if record.expire_at < datetime.utcnow():
+            logger.warning(f"⚠️ [AUTH] Password reset token expired for {payload.email}")
             raise BizLogicError("Token expired")
 
         user.password_hash = bcrypt.hashpw(
@@ -277,6 +291,7 @@ class AuthService:
         record.used = 1
 
         await db.commit()
+        logger.info(f"🔑 [AUTH] Password reset successful for user={user.id} email={user.email}")
         return True
 
     # =========================
@@ -292,12 +307,14 @@ class AuthService:
         stmt = select(VasUser).where(VasUser.email == req.email)
         user = (await db.execute(stmt)).scalar_one_or_none()
         if not user:
+            logger.warning(f"⚠️ [AUTH] Login failed: User not found for email={req.email} ip={ip or 'unknown'}")
             raise NotFoundError("User not found")
 
         if not bcrypt.checkpw(
             req.password.encode(),
             user.password_hash.encode(),
         ):
+            logger.warning(f"⚠️ [AUTH] Login failed: Password incorrect for email={req.email} user={user.id} ip={ip or 'unknown'}")
             raise PermissionDeniedError("Password incorrect")
 
         token = "tok_" + uuid.uuid4().hex
@@ -311,4 +328,6 @@ class AuthService:
         db.add(session)
         await db.commit()
 
+        logger.info(f"🔓 [AUTH] User login successful: user={user.id} email={user.email} ip={ip or 'unknown'}")
         return {"user": user, "token": token}
+

+ 11 - 94
app/services/emails_service.py

@@ -1,18 +1,14 @@
 import re
-import asyncio
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select, func
 from app.core.logger import logger
 from app.schemas.order_event import VasOrderEventCreate
 from app.services.order_event_service import OrderEventService
-from app.services.notification_service import NotificationService
-from app.models.order import VasOrder
-from app.models.user import VasUser
 from app.models.emails import VasEmail
 from app.schemas.emails import VasEmailCreate
 
 class EmailsService:
-    # 关键词黑名单:匹配到这些词的邮件不会创建订单事件,也不会通知用户
+    # 关键词黑名单:匹配到这些词的邮件不会创建订单事件
     SUBJECT_BLACKLIST = [
         "验证码",
         "动态码",
@@ -67,8 +63,8 @@ class EmailsService:
         )
         db.add(rec)
         
-        # 3. 拦截、匹配订单并入库通知 (此时还在同一个事务中)
-        await EmailsService._intercept_and_notify(db, rec)
+        # 3. 拦截、匹配订单并创建订单事件 (此时还在同一个事务中)
+        await EmailsService._intercept(db, rec)
         
         # 4. 统一提交
         await db.commit()
@@ -82,23 +78,21 @@ class EmailsService:
         return await db.scalar(stmt) or 0
 
     @staticmethod
-    async def _intercept_and_notify(db: AsyncSession, rec: VasEmail) -> None:
+    async def _intercept(db: AsyncSession, rec: VasEmail) -> None:
         """
         拦截处理逻辑:
         1. 黑名单过滤
         2. 创建订单事件 (OrderEventService)
-        3. 获取订单关联的用户联系方式
-        4. post_message 到通知表
         """
         if EmailsService._is_subject_blacklisted(rec.subject or ""):
             logger.info(f"Email {rec.uid} skipped: subject '{rec.subject}' is in blacklist.")
             return
         
         if EmailsService._is_sender_blacklisted(rec.sender or ""):
-            logger.info(f"Email {rec.uid} skipped: subject '{rec.sender}' is in blacklist.")
+            logger.info(f"Email {rec.uid} skipped: sender '{rec.sender}' is in blacklist.")
             return
 
-        # 1. 尝试创建订单事件 (OrderEventService 内部会根据 rec.recipient 匹配订单)
+        # 尝试创建订单事件 (OrderEventService 内部会根据 rec.recipient 匹配订单)
         try:
             event = await OrderEventService.create(
                 db,
@@ -111,87 +105,10 @@ class EmailsService:
                     event_time=None,
                 ),
             )
+            if event and event.order_no:
+                logger.info(f"Email {rec.uid} intercepted and logged to Order {event.order_no}.")
+            else:
+                logger.info(f"Email {rec.uid} logged, but no matching active order found for {rec.recipient}.")
         except Exception as e:
             logger.warning(f"Failed to create order event for email {rec.uid}: {e}")
-            return
-
-        # 2. 如果邮件没能关联到任何活跃订单,则不通知
-        if not event or not event.order_no:
-            logger.info(f"Email {rec.uid} logged, but no matching active order found for {rec.recipient}.")
-            return
-
-        # 3. 获取订单及用户信息
-        stmt = select(VasOrder).where(VasOrder.id == event.order_no)
-        order = (await db.execute(stmt)).scalar_one_or_none()
-        if not order:
-            return
-
-        user = await db.get(VasUser, order.user_id)
-        user_inputs = order.user_inputs or {}
-
-        # 优先级:数据库用户字段 > 订单输入的联系方式
-        email_to = (user.email if user else None) or user_inputs.get("email")
-        # phone = (user.phone if user else None) or user_inputs.get("phone")
-        # country_code = str(user_inputs.get("phone_country_code") or "")
-
-        # 4. 构造通知内容
-        summary = EmailsService._summarize(rec.body_text or "")
-        
-        # --- 邮件转发任务 ---
-        if email_to:
-            subject = f"Update: {rec.subject or 'Visa Appointment Progress'}"
-            await NotificationService.post_message(
-                db=db,
-                channel="email",
-                payload={
-                    "template_id": "order_event_update",
-                    "receiver": email_to,
-                    "payload": {
-                        "subject": subject,
-                        "summary": summary,
-                        "order_no": order.id,
-                    },
-                },
-            )
-
-        # --- WhatsApp 推送任务 ---
-        # if phone:
-        #     # 确保国家代码不带 +
-        #     code = str(user_inputs.get("phone_country_code") or "").replace("+", "")
-        #     # 去掉手机号开头的 0
-        #     clean_phone = str(phone).lstrip('0')
-            
-        #     # 组合纯数字部分
-        #     digits = f"{code}{clean_phone}"
-        #     # 再次利用正则确保只剩数字(以防 code 包含特殊字符)
-        #     digits = re.sub(r"\D", "", digits)
-
-        #     if "@lid" in str(phone):
-        #         chat_id = phone
-        #     elif digits:
-        #         # 使用不带 + 的纯数字拼接后缀
-        #         chat_id = f"{digits}@c.us"
-        #     else:
-        #         return
-
-        #     message = (
-        #         f"🔔 *Progress Update*\n\n"
-        #         f"We received an update for your appointment:\n"
-        #         f"_{summary}_\n\n"
-        #         f"Please log in to your dashboard or check your email for full details."
-        #     )
-
-        #     await NotificationService.post_message(
-        #         db=db,
-        #         channel="whatsapp",
-        #         payload={
-        #             "template_id": "order_event_update",
-        #             "receiver": chat_id,
-        #             "payload": {
-        #                 "message": message,
-        #                 "order_no": order.id,
-        #             },
-        #         },
-        #     )
-            
-        logger.info(f"Notification tasks queued for Email {rec.uid} (Order: {order.id})")
+            return

+ 0 - 150
app/services/fake_service.py

@@ -1,150 +0,0 @@
-import json
-import random
-import aiohttp
-import asyncio
-import string
-import uuid
-
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, delete
-from app.core.biz_exception import NotFoundError, PermissionDeniedError, BizLogicError
-from app.models.user import VasUser
-from app.models.product import VasProduct
-from app.models.schema import VasSchema
-from app.schemas.order import VasOrderCreate
-from typing import List, Optional
-from datetime import date, datetime, timedelta
-from app.services.order_service import OrderService
-# ----------------------------------------
-# 邮箱域名
-# ----------------------------------------
-DOMAINS = [
-    "gmail-app.com",
-    "outlooksearch.com",
-    "hotmails.vip",
-    "gmail365.cc",
-    "ymails.top",
-    "teamymail.cfd"
-]
-
-class FakeService:
-    
-    RANDOM_USER_API = "https://randomuser.me/api/?nat=ie"
-
-    @staticmethod
-    def random_passport():
-        """生成简单护照号"""
-        prefix = random.choice(["P", "L", "X"])
-        digits = "".join(random.choices(string.digits, k=8))
-        return prefix + digits
-
-    @staticmethod
-    def random_passport_expiry():
-        """护照有效期 3-10 年"""
-        today = datetime.today()
-        future = today + timedelta(days=random.randint(3*365, 10*365))
-        return future.strftime("%Y-%m-%d")
-
-    @staticmethod
-    def random_expected_dates():
-        """预约时间范围"""
-        start = datetime.today() + timedelta(days=4)
-        end = start + timedelta(days=random.randint(7, 60))
-        return start.strftime("%Y-%m-%d"), end.strftime("%Y-%m-%d")
-    
-    @staticmethod
-    def random_gmail(first, last):
-        """
-        生成随机 Gmail
-        """
-        first = first.lower()
-        last = last.lower()
-
-        patterns = [
-            f"{first}{random.randint(10,99)}",
-            f"{first}.{last}{random.randint(10,999)}",
-            f"{first[0]}{last}{random.randint(100,999)}"
-            f"{first}{uuid.uuid4().hex[:3]}",
-            f"{first}.{uuid.uuid4().hex[:4]}",
-            f"{first[0]}{uuid.uuid4().hex[:5]}"
-            
-        ]
-
-        name = random.choice(patterns)
-
-        return f"{name}@gmail.com"
-
-    @staticmethod
-    async def fetch_irish_users(num: int):
-
-        url = f"https://randomuser.me/api/?results={num}&nat=ie"
-
-        async with aiohttp.ClientSession() as session:
-            async with session.get(url) as resp:
-                data = await resp.json()
-
-        return data["results"]
-    
-    @staticmethod
-    async def generate_visametric_applicants(num: int):
-
-        users = await FakeService.fetch_irish_users(num)
-
-        results = []
-
-        for u in users:
-
-            first = u["name"]["first"]
-            last = u["name"]["last"]
-            start_date, end_date = FakeService.random_expected_dates()
-
-            item = {
-                "first_name": u["name"]["first"],
-                "last_name": u["name"]["last"],
-                "birthday": u["dob"]["date"][:10],
-                "passport_no": FakeService.random_passport(),
-                "passport_expiry_date": FakeService.random_passport_expiry(),
-                "email": FakeService.random_gmail(first, last),
-                "phone_country_code": "353",
-                "phone": u["cell"].replace(" ", "").replace("-", ""),
-                "expected_start_date": start_date,
-                "expected_end_date": end_date,
-                "social_media_account": f"fake-{u['login']['username']}"
-            }
-
-            results.append(item)
-
-        return results
-    
-    @staticmethod
-    async def generate_orders(db: AsyncSession, num: int, product_id: int, auth_user: VasUser):
-        stmt = select(VasProduct).where(VasProduct.id == product_id)
-        product_obj = (await db.execute(stmt)).scalar_one_or_none()
-        if not product_obj:
-            raise NotFoundError("Product not exist")
-        
-        schema_id = product_obj.schema_id
-        stmt = select(VasSchema).where(VasSchema.id == schema_id)
-        schema_obj = (await db.execute(stmt)).scalar_one_or_none()
-        if not schema_obj:
-            raise NotFoundError("Schema not exist")
-        schmea_json = schema_obj.schema_json
-        
-        applicants = await FakeService.generate_visametric_applicants(num=num)
-        
-        orders = []
-        print(json.dumps(applicants, ensure_ascii=False, indent=2))
-        for app in applicants:
-            order_data = VasOrderCreate(
-                product_id=product_id,
-                user_inputs=app
-            )
-
-            obj = await OrderService.create_by_admin(
-                db=db,
-                data=order_data,
-                product=product_obj,
-                auth_user=auth_user
-            )
-            orders.append(obj)
-        return orders

+ 136 - 65
app/services/llm_service.py

@@ -2,97 +2,168 @@ import aiohttp
 import asyncio
 import json
 import os
+import re
+from typing import Optional, Dict, Any
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
 from app.core.config import settings
-from app.core.biz_exception import NotFoundError
+from app.core.biz_exception import NotFoundError, BizLogicError
+from app.core.logger import logger
 from app.schemas.llm import ParseUserInputsPayload, ParseUserInputsOut
 from app.models.schema import VasSchema
 
-# --- 配置区 ---
-# 请换成你新生成的 API Key
-API_KEY = settings.openai_api_key
-
-# API_URL = "https://api.openai.com/v1/chat/completions"
-API_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions"
 
 class LlmService:
+    """
+    通用 LLM 服务(OpenAI-compatible 协议)
+    支持 Qwen (DashScope)、OpenAI、DeepSeek、Moonshot、Ollama 等任意标准兼容模型
+    """
+
+    @classmethod
+    def get_api_key(cls) -> str:
+        """获取 API Key(优先读取 settings.llm_api_key,其次读取环境变量 LLM_API_KEY)"""
+        return (
+            (settings.llm_api_key or "").strip()
+            or os.getenv("LLM_API_KEY", "").strip()
+        )
+
+
+    @classmethod
+    def get_completions_url(cls) -> str:
+        """获取并规范化 /chat/completions 完整请求 URL"""
+        base = (
+            (settings.llm_base_url or "").strip()
+            or os.getenv("LLM_BASE_URL", "https://dashscope.aliyuncs.com/compatible-mode/v1").strip()
+        ).rstrip("/")
+        
+        if base.endswith("/chat/completions"):
+            return base
+        return f"{base}/chat/completions"
+
+    @classmethod
+    def get_default_model(cls) -> str:
+        """获取默认模型名称"""
+        return (
+            (settings.llm_model or "").strip()
+            or os.getenv("LLM_MODEL", "qwen-plus").strip()
+        )
 
-    async def handle_parse(db: AsyncSession, payload: ParseUserInputsPayload):
+    @classmethod
+    def clean_json_response(cls, content_str: str) -> Dict[str, Any]:
+        """
+        从 LLM 返回的内容中提取并解析合法 JSON,自动剥离 Markdown 代码块
+        """
+        if not content_str:
+            return {}
+
+        text = content_str.strip()
+
+        # 匹配 ```json ... ``` 或 ``` ... ```
+        code_block_match = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", text, re.IGNORECASE)
+        if code_block_match:
+            text = code_block_match.group(1).strip()
+
+        # 尝试直接解析
+        try:
+            return json.loads(text)
+        except json.JSONDecodeError:
+            # 尝试提取最外层的 { ... }
+            brace_match = re.search(r"(\{[\s\S]*\})", text)
+            if brace_match:
+                return json.loads(brace_match.group(1))
+            raise
+
+    @classmethod
+    async def handle_parse(cls, db: AsyncSession, payload: ParseUserInputsPayload) -> ParseUserInputsOut:
+        """
+        处理数据解析接口请求
+        """
         stmt = select(VasSchema).where(VasSchema.id == payload.schema_id)
         obj = (await db.execute(stmt)).scalar_one_or_none()
         if not obj:
             raise NotFoundError("Schema not exist")
-        parsed_obj = await LlmService.parse_data_async(payload.input_raw_str, obj.schema_json)
-        out = ParseUserInputsOut(parsed_obj=parsed_obj)
-        return out
-    
-    @staticmethod
-    async def parse_data_async(user_text: str, json_schema: dict):
+
+        parsed_obj = await cls.parse_data_async(
+            user_text=payload.input_raw_str,
+            json_schema=obj.schema_json,
+            model=payload.model
+        )
+        return ParseUserInputsOut(parsed_obj=parsed_obj)
+
+    @classmethod
+    async def parse_data_async(
+        cls,
+        user_text: str,
+        json_schema: dict,
+        model: Optional[str] = None,
+        max_retries: int = 1
+    ) -> Dict[str, Any]:
         """
-        [异步版本] 调用 LLM 解析数据
+        [异步版本] 调用配置好的 OpenAI 兼容接口解析数据
         """
+        api_key = cls.get_api_key()
+        if not api_key:
+            logger.warning("[LlmService] No LLM API Key configured.")
+            return {"error": "LLM API Key not configured"}
+
+        url = cls.get_completions_url()
+        selected_model = (model or "").strip() or cls.get_default_model()
+        temperature = settings.llm_temperature
+        timeout_seconds = settings.llm_timeout_seconds or 30
+
         headers = {
-            "Authorization": f"Bearer {API_KEY}",
-            "Content-Type": "application/json"
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
         }
 
         # 构造 Prompt
         system_instruction = "You are a specialized data extraction API. Output valid JSON only."
-        
         user_prompt = f"""
-        Extract data from the text strictly based on the provided JSON Schema.
-        
-        [JSON Schema]
-        {json.dumps(json_schema)}
-        
-        [User Text]
-        {user_text}
-        """
+Extract data from the text strictly based on the provided JSON Schema.
+
+[JSON Schema]
+{json.dumps(json_schema, ensure_ascii=False)}
+
+[User Text]
+{user_text}
+"""
 
         payload = {
-            # "model": "gpt-4o",  # 或 gpt-3.5-turbo
-            "model": "qwen-plus",
+            "model": selected_model,
             "messages": [
                 {"role": "system", "content": system_instruction},
                 {"role": "user", "content": user_prompt}
             ],
-            "temperature": 0,
-            "response_format": {"type": "json_object"} # 强制 JSON 模式
+            "temperature": temperature,
+            "response_format": {"type": "json_object"}
         }
 
-  
-        async with aiohttp.ClientSession() as session:
-            async with session.post(API_URL, headers=headers, json=payload, timeout=30) as response:
-                
-                # 1. 检查 HTTP 状态码
-                if response.status != 200:
-                    error_text = await response.text()
-                    return {"error": f"HTTP {response.status}", "detail": error_text}
-                
-                # 2. 获取响应体
-                result = await response.json()
-                
-                # 3. 提取并解析内容
-                content_str = result['choices'][0]['message']['content']
-                return json.loads(content_str)
-
-# --- 测试运行 ---
-if __name__ == "__main__":
-    # 定义你的 Schema
-    my_schema = {
-        "type": "object",
-        "properties": {
-            "full_name": {"type": "string"},
-            "budget": {"type": "integer"},
-            "items": {"type": "array", "items": {"type": "string"}}
-        },
-        "required": ["full_name", "budget"]
-    }
-
-    # 模拟用户输入
-    user_input = "我是张三,打算花2000块钱买个耳机和键盘。"
-    
-    print("正在解析...")
-    result = LlmService.parse_data_async(user_input, my_schema)
-    print(json.dumps(result, ensure_ascii=False, indent=2))
+        timeout = aiohttp.ClientTimeout(total=float(timeout_seconds))
+
+        for attempt in range(max_retries + 1):
+            try:
+                async with aiohttp.ClientSession(timeout=timeout) as session:
+                    async with session.post(url, headers=headers, json=payload) as response:
+                        if response.status != 200:
+                            error_text = await response.text()
+                            logger.error(f"[LlmService] HTTP {response.status} from {url}: {error_text}")
+                            if attempt == max_retries:
+                                return {"error": f"HTTP {response.status}", "detail": error_text}
+                            await asyncio.sleep(0.5)
+                            continue
+
+                        result = await response.json()
+                        choices = result.get("choices", [])
+                        if not choices:
+                            return {"error": "No completion choices returned"}
+
+                        content_str = choices[0].get("message", {}).get("content", "")
+                        return cls.clean_json_response(content_str)
+
+            except Exception as e:
+                logger.error(f"[LlmService] Exception on attempt {attempt + 1}: {e}")
+                if attempt == max_retries:
+                    return {"error": "LLM invocation error", "detail": str(e)}
+                await asyncio.sleep(0.5)
+
+        return {"error": "LLM request failed"}

+ 12 - 2
app/services/order_service.py

@@ -8,6 +8,7 @@ from redis.asyncio import Redis
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
 
+from app.core.logger import logger
 from app.utils.search import apply_keyword_search_stmt
 from app.utils.pagination import paginate
 from app.core.biz_exception import NotFoundError, BizLogicError
@@ -54,7 +55,9 @@ class OrderService:
         await db.commit()
         await db.refresh(order)
 
+        logger.info(f"📦 [ORDER] Created order: id={order.id} product={product.id} user={auth_user.id} amount={order.final_amount} {order.base_currency}")
         return order
+
     
     @staticmethod
     async def cancel(
@@ -79,6 +82,7 @@ class OrderService:
             
         await db.commit()
         await db.refresh(order)
+        logger.info(f"🚫 [ORDER] Cancelled order: id={order.id} and its associated tasks")
         return order
     
     @staticmethod
@@ -125,6 +129,7 @@ class OrderService:
         
         await db.commit()
         await db.refresh(order)
+        logger.info(f"👑 [ORDER] Admin created order: id={order.id} product={product.id} user={auth_user.id} status=paid")
         return order
     
     @staticmethod
@@ -133,12 +138,15 @@ class OrderService:
         order = (await db.execute(stmt)).scalar_one_or_none()
 
         if not order:
+            logger.warning(f"⚠️ [ORDER] Price adjust failed: Order {order_id} not found")
             raise NotFoundError("Order not exist")
 
         if order.status != "pending":
+            logger.warning(f"⚠️ [ORDER] Price adjust failed: Order {order_id} status is {order.status} (expected pending)")
             raise BizLogicError(message="Order not adjustable")
 
         # 2. 更新订单价格
+        old_amount = order.final_amount
         order.adjustment_delta = payload.adjustment_delta
         order.final_amount = order.base_amount + payload.adjustment_delta
 
@@ -157,6 +165,7 @@ class OrderService:
 
         await db.commit()
         await db.refresh(order)
+        logger.info(f"💰 [ORDER] Adjusted order price: id={order.id} old={old_amount} new={order.final_amount} delta={payload.adjustment_delta}")
         return order
 
     @staticmethod
@@ -210,10 +219,10 @@ class OrderService:
         order = (await db.execute(stmt)).scalar_one_or_none()
 
         if not order:
+            logger.warning(f"⚠️ [ORDER] Patch user_inputs failed: Order {order_id} not found")
             raise NotFoundError("Order not exist")
 
         order.user_inputs = payload.user_inputs
-        
 
         # 1️⃣ 取消旧任务
         task_res = await db.execute(
@@ -228,8 +237,9 @@ class OrderService:
         await db.flush()
         await WebhookService._create_task_if_not_exists(db, order)
         
-        
         await db.commit()
         await db.refresh(order)
 
+        logger.info(f"🔄 [ORDER] Patched user inputs for order {order.id}, recreated tasks")
         return order
+

+ 6 - 1
app/services/payment_service.py

@@ -13,6 +13,7 @@ from datetime import datetime, timedelta
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
 
+from app.core.logger import logger
 from app.utils.search import apply_keyword_search_stmt
 from app.utils.pagination import paginate
 from app.core.biz_exception import NotFoundError, BizLogicError
@@ -33,6 +34,7 @@ from app.services.notification_service import NotificationService
 from app.services.webhook_service import WebhookService
 
 
+
 def convert_currency(
     amount: int,
     from_currency: str,
@@ -192,7 +194,7 @@ class PaymentService:
         payment = (await db.execute(stmt)).scalar_one_or_none()
 
         formatted_time = payload.confirmed_at.strftime('%Y-%m-%d %H:%M') + " (UTC)"
-        # 2️⃣ 推送异步通知给管理员
+        logger.info(f"💳 [PAYMENT] User confirmed payment: payment_id={payload.payment_id} user={current_user.id} amount={payload.amount} {payload.currency}")
         await NotificationService.post_message(
             db=db,
             channel="wechat",
@@ -230,6 +232,7 @@ class PaymentService:
         record = result.scalar_one_or_none()
 
         if not record:
+            logger.warning(f"⚠️ [PAYMENT] Admin confirm failed: confirmation record {id} not found")
             raise NotFoundError("Payment confirmation record not found")
 
         # 3️⃣ 更新管理员确认状态
@@ -241,7 +244,9 @@ class PaymentService:
         await db.commit()
         await db.refresh(record)
 
+        logger.info(f"👑 [PAYMENT] Admin confirmed payment: confirmation_id={id} payment_id={record.payment_id} admin={current_user.id}")
         return record
+
     
     @staticmethod
     async def admin_update_status(

+ 0 - 63
app/services/scheduler_handlers.py

@@ -1,63 +0,0 @@
-from app.services.scheduler_service import register_scheduled_task, scheduler_service
-from app.core.logger import logger
-
-
-@register_scheduled_task(name="visametric_slot_expire_checker", interval_hours=1)
-async def visametric_slot_expire_checker():
-    """
-    检查 vas_task 中状态为 grabbed 的任务,
-    如果 grabbed_history 中的 slot_date 距离现在不足4天,发送企业微信通知
-    """
-    from app.core.database import AsyncSessionLocal
-    from sqlalchemy import select
-    from datetime import datetime, timedelta
-    from app.models.vas_task import VasTask
-    from app.services.wechat_service import WechatService
-
-    try:
-        expire_days = 4
-        now = datetime.utcnow()
-        threshold_date = (now + timedelta(days=expire_days)).strftime("%Y-%m-%d")
-
-        async with AsyncSessionLocal() as db:
-            stmt = select(VasTask).where(
-                VasTask.routing_key == "auto.slot.dub.de.tourist",
-                VasTask.status == "grabbed"
-            )
-            result = await db.execute(stmt)
-            tasks = result.scalars().all()
-
-            expiring_tasks = []
-            for task in tasks:
-                grabbed_history = task.grabbed_history or {}
-                slot_date_str = grabbed_history.get("slot_date", "")
-                if not slot_date_str:
-                    continue
-
-                try:
-                    try:
-                        slot_date = datetime.strptime(slot_date_str, "%Y-%m-%d")
-                    except ValueError:
-                        slot_date = datetime.strptime(slot_date_str, "%d/%m/%Y")
-                    if slot_date <= now + timedelta(days=expire_days):
-                        expiring_tasks.append({
-                            "order_id": task.order_id,
-                            "slot_date": slot_date_str,
-                            "slot_time": grabbed_history.get("slot_time", "N/A"),
-                        })
-                except ValueError:
-                    logger.warning(f"[Scheduler] Invalid slot_date format: {slot_date_str}")
-
-            if expiring_tasks:
-                lines = [f"⚠️ 以下德签 slot 即将到期(不足 {expire_days} 天):"]
-                for t in expiring_tasks:
-                    lines.append(f"- 订单号: {t['order_id']}, Slot: {t['slot_date']} {t['slot_time']}")
-
-                content = "\n".join(lines)
-                await WechatService.push_markdown_no_token(content)
-                logger.info(f"[Scheduler] Sent WeChat notification for {len(expiring_tasks)} expiring tasks")
-            else:
-                logger.info("[Scheduler] No expiring tasks found")
-
-    except Exception as e:
-        logger.error(f"[Scheduler] Error in visametric_slot_expire_checker: {e}")

+ 0 - 97
app/services/scheduler_service.py

@@ -1,97 +0,0 @@
-import asyncio
-import threading
-from typing import Callable, List, Dict, Any
-from apscheduler.schedulers.asyncio import AsyncIOScheduler
-from apscheduler.triggers.interval import IntervalTrigger
-from apscheduler.events import EVENT_JOB_ERROR, EVENT_JOB_EXECUTED
-from app.core.logger import logger
-
-
-class ScheduledTask:
-    def __init__(self, name: str, handler: Callable, interval_hours: int = 1):
-        self.name = name
-        self.handler = handler
-        self.interval_hours = interval_hours
-
-
-class SchedulerService:
-    _instance = None
-    _lock = threading.Lock()
-    _scheduler: AsyncIOScheduler = None
-    _tasks: List[ScheduledTask] = []
-    _started = False
-
-    @classmethod
-    def get_instance(cls) -> "SchedulerService":
-        if cls._instance is None:
-            with cls._lock:
-                if cls._instance is None:
-                    cls._instance = cls()
-        return cls._instance
-
-    def __init__(self):
-        self._scheduler = AsyncIOScheduler(timezone="UTC")
-        self._setup_event_listeners()
-
-    def _setup_event_listeners(self):
-        def on_job_error(event):
-            logger.error(f"[Scheduler] Job {event.job_id} error: {event.exception}")
-
-        def on_job_executed(event):
-            if event.exception is None:
-                logger.info(f"[Scheduler] Job {event.job_id} completed successfully")
-            else:
-                logger.error(f"[Scheduler] Job {event.job_id} failed: {event.exception}")
-
-        self._scheduler.add_listener(on_job_error, EVENT_JOB_ERROR)
-        self._scheduler.add_listener(on_job_executed, EVENT_JOB_EXECUTED)
-
-    def register_task(self, name: str, handler: Callable, interval_hours: int = 1):
-        task = ScheduledTask(name=name, handler=handler, interval_hours=interval_hours)
-        self._tasks.append(task)
-        logger.info(f"[Scheduler] Registered task: {name} (interval: {interval_hours}h)")
-
-    def start(self):
-        if self._started:
-            logger.warning("[Scheduler] Already started")
-            return
-
-        for task in self._tasks:
-            self._scheduler.add_job(
-                task.handler,
-                IntervalTrigger(hours=task.interval_hours),
-                id=task.name,
-                replace_existing=True,
-                misfire_grace_time=3600,
-            )
-            logger.info(f"[Scheduler] Scheduled task: {task.name} every {task.interval_hours}h")
-
-        self._scheduler.start()
-        self._started = True
-        logger.info("[Scheduler] Started successfully")
-
-    def stop(self):
-        if self._scheduler.running:
-            self._scheduler.shutdown(wait=False)
-            self._started = False
-            logger.info("[Scheduler] Stopped")
-
-    def get_jobs(self) -> List[Dict[str, Any]]:
-        jobs = []
-        for job in self._scheduler.get_jobs():
-            jobs.append({
-                "id": job.id,
-                "next_run": str(job.next_run_time) if job.next_run_time else None,
-                "interval_hours": job.trigger.interval_hours if hasattr(job.trigger, 'interval_hours') else None,
-            })
-        return jobs
-
-
-scheduler_service = SchedulerService.get_instance()
-
-
-def register_scheduled_task(name: str, interval_hours: int = 1):
-    def decorator(func: Callable):
-        scheduler_service.register_task(name, func, interval_hours)
-        return func
-    return decorator

+ 174 - 125
app/services/seaweedfs_service.py

@@ -1,169 +1,218 @@
 import os
 import aiohttp
+import asyncio
+from typing import Optional, Tuple, Dict, Any
+from urllib.parse import urlparse
 from fastapi import UploadFile
+from app.core.config import settings
 from app.core.biz_exception import BizLogicError
 from app.core.logger import logger
 
+
 class SeaweedFSService:
-    # 1. 优先读取环境变量,默认使用 Docker 内部网络的服务名
-    # 只要后端和 SeaweedFS 在同一个 Docker 网络 (textskin-net),这个地址就是通的
-    MASTER_URL = os.getenv("SEAWEEDFS_MASTER_URL", "http://seaweedfs-master:9333")
-    
-    # 文件下载的公网入口(经过你的 Nginx + Backend 代理)
-    DOWNLOAD_GATEWAY = "https://api.text.skin/api/resource/download_file"
+    """
+    SeaweedFS 分布式存储服务
+    具备环境自适应、Volume 地址重写规整、动态下载网关及重试容错能力
+    """
+
+    @classmethod
+    def get_master_url(cls) -> str:
+        """获取并规整 Master URL(优先读取 settings,兼容环境变量)"""
+        url = settings.seaweedfs_master_url or os.getenv("SEAWEEDFS_MASTER_URL", "http://seaweedfs-master:9333")
+        url = url.strip().rstrip("/")
+        if not url.startswith("http://") and not url.startswith("https://"):
+            url = f"http://{url}"
+        return url
+
+    @classmethod
+    def get_download_url(cls, fid: str) -> str:
+        """根据当前配置的 API Base URL 动态生成公网下载地址"""
+        base = (settings.api_base_url or os.getenv("API_BASE_URL", "https://api.text.skin")).strip().rstrip("/")
+        return f"{base}/api/resource/download_file?fid={fid}"
 
     @classmethod
-    async def upload(cls, file: UploadFile):
+    def resolve_volume_url(cls, raw_url: str, fid: str) -> str:
         """
-        上传文件到 SeaweedFS
+        智能解析并规整 Volume Server 访问地址:
+        1. 自动处理协议前缀 (http:// / https://)
+        2. 如果配置了 seaweedfs_volume_override_host,则将 Master 返回的主机/IP 替换为覆盖主机,保留端口
+        3. 拼接目标 fid
         """
-        try:
-            timeout = aiohttp.ClientTimeout(total=10.0)
-            async with aiohttp.ClientSession(timeout=timeout) as client:
-                # 1️⃣ 向 Master 申请 fid
-                # logger.info(f"Connecting to SeaweedFS Master: {cls.MASTER_URL}")
-                try:
-                    async with client.get(f"{cls.MASTER_URL}/dir/assign") as assign_resp:
+        if not raw_url:
+            return ""
+
+        raw = raw_url.strip()
+        has_scheme = raw.startswith("http://") or raw.startswith("https://")
+        if not has_scheme:
+            raw = f"http://{raw}"
+
+        parsed = urlparse(raw)
+        scheme = parsed.scheme or "http"
+        port = parsed.port
+
+        override_host = (settings.seaweedfs_volume_override_host or os.getenv("SEAWEEDFS_VOLUME_OVERRIDE_HOST", "")).strip()
+        if override_host:
+            # 如果 override_host 自带端口,直接使用;否则保留原始端口
+            if ":" in override_host:
+                netloc = override_host
+            elif port:
+                netloc = f"{override_host}:{port}"
+            else:
+                netloc = override_host
+        else:
+            netloc = parsed.netloc
+
+        base_volume = f"{scheme}://{netloc}".rstrip("/")
+        return f"{base_volume}/{fid}"
+
+    @classmethod
+    async def upload(cls, file: UploadFile, max_retries: int = 2) -> Dict[str, Any]:
+        """
+        上传文件到 SeaweedFS(带自动重试与 Volume 地址自适应)
+        """
+        file_content = await file.read()
+        filename = file.filename or "file.bin"
+        content_type = file.content_type or "application/octet-stream"
+
+        master_url = cls.get_master_url()
+        timeout = aiohttp.ClientTimeout(total=15.0)
+
+        for attempt in range(max_retries + 1):
+            try:
+                async with aiohttp.ClientSession(timeout=timeout) as client:
+                    # 1. 向 Master 申请 fid 和 volume 地址
+                    assign_url = f"{master_url}/dir/assign"
+                    async with client.get(assign_url) as assign_resp:
                         if assign_resp.status >= 300:
-                            raise BizLogicError("Storage service unavailable")
+                            err_text = await assign_resp.text()
+                            raise BizLogicError(f"Storage master assign failed: {assign_resp.status} - {err_text}")
                         assign_data = await assign_resp.json()
-                except Exception as e:
-                    logger.error(f"Failed to connect to Master at {cls.MASTER_URL}. Error: {e}")
-                    raise BizLogicError("Storage service unavailable")
-                fid = assign_data.get("fid")
-                
-                # 2️⃣ 获取上传地址
-                # 在 Docker 共享网络模式下,Master 返回的 publicUrl 就是 "seaweedfs-volume:8080"
-                # 后端可以直接解析并访问这个地址,无需任何修改
-                public_url = assign_data.get("publicUrl")
-                
-                if not public_url:
-                    raise BizLogicError("No volume server available")
-
-                upload_url = f"http://{public_url}/{fid}"
-                download_url = f"{cls.DOWNLOAD_GATEWAY}?fid={fid}"
-
-                # 3️⃣ 上传文件数据
-                # 读取文件内容
-                file_content = await file.read()
-                files = {
-                    "file": (
-                        file.filename,
-                        file_content,
-                        file.content_type or "application/octet-stream",
-                    )
-                }
-
-                # logger.info(f"Uploading to Volume Node: {upload_url}")
-                form = aiohttp.FormData()
-                form.add_field(
-                    "file",
-                    file_content,
-                    filename=file.filename,
-                    content_type=file.content_type or "application/octet-stream",
-                )
-                async with client.post(upload_url, data=form) as upload_resp:
-                    status = upload_resp.status
-                    resp_text = await upload_resp.text()
-
-                if status == 201:
-                    return {
-                        "fid": fid,
-                        "url": download_url,
-                        "size": len(file_content)
-                    }
-
-                logger.error(f"Upload failed. Status: {status}, Body: {resp_text}")
-                raise BizLogicError(f"Storage upload error: {resp_text}")
-
-        except BizLogicError as e:
-            raise e
-        except Exception as e:
-            logger.exception("SeaweedFS upload unexpected error")
-            raise BizLogicError(f"Upload exception: {str(e)}")
+
+                    fid = assign_data.get("fid")
+                    public_url = assign_data.get("publicUrl") or assign_data.get("url")
+                    if not fid or not public_url:
+                        raise BizLogicError("Invalid response from storage master: missing fid or volume url")
+
+                    # 2. 解析可达的 Volume 上传地址
+                    upload_url = cls.resolve_volume_url(public_url, fid)
+
+                    # 3. 构造表单并上传文件
+                    form = aiohttp.FormData()
+                    form.add_field("file", file_content, filename=filename, content_type=content_type)
+
+                    async with client.post(upload_url, data=form) as upload_resp:
+                        status = upload_resp.status
+                        resp_text = await upload_resp.text()
+
+                    if status in (200, 201):
+                        return {
+                            "fid": fid,
+                            "url": cls.get_download_url(fid),
+                            "size": len(file_content),
+                        }
+
+                    raise BizLogicError(f"Volume upload failed (status {status}): {resp_text}")
+
+            except BizLogicError as e:
+                if attempt == max_retries:
+                    logger.error(f"[SeaweedFS] Upload failed after {attempt + 1} attempts: {e}")
+                    raise e
+                logger.warning(f"[SeaweedFS] Upload attempt {attempt + 1} failed: {e}. Retrying...")
+                await asyncio.sleep(0.5 * (attempt + 1))
+            except Exception as e:
+                if attempt == max_retries:
+                    logger.exception(f"[SeaweedFS] Upload unexpected error on attempt {attempt + 1}")
+                    raise BizLogicError(f"Storage service unavailable: {str(e)}")
+                logger.warning(f"[SeaweedFS] Network error on attempt {attempt + 1}: {e}. Retrying...")
+                await asyncio.sleep(0.5 * (attempt + 1))
+
+        raise BizLogicError("Storage upload failed")
 
     @classmethod
-    async def get(cls, fid: str):
+    async def get(cls, fid: str, max_retries: int = 2) -> Optional[Tuple[bytes, str]]:
         """
-        根据 fid 读取文件流
+        根据 fid 读取文件流及 Content-Type(带重试与自适应)
         """
-        try:
-            if not fid:
-                return None
-                
-            # fid 格式通常是 "3,016a...",逗号前是 volumeId
-            volume_id = fid.split(",")[0]
+        if not fid:
+            return None
 
-            timeout = aiohttp.ClientTimeout(total=10.0)
-            async with aiohttp.ClientSession(timeout=timeout) as client:
-                # 1️⃣ 查询文件位置
-                async with client.get(
-                    f"{cls.MASTER_URL}/dir/lookup",
-                    params={"volumeId": volume_id},
-                ) as lookup_resp:
-                    if lookup_resp.status != 200:
-                        text = await lookup_resp.text()
-                        logger.warning(f"Lookup failed for fid {fid}: {text}")
+        volume_id = fid.split(",")[0]
+        master_url = cls.get_master_url()
+        timeout = aiohttp.ClientTimeout(total=10.0)
+
+        for attempt in range(max_retries + 1):
+            try:
+                async with aiohttp.ClientSession(timeout=timeout) as client:
+                    # 1. 向 Master 查询 Volume 位置
+                    lookup_url = f"{master_url}/dir/lookup"
+                    async with client.get(lookup_url, params={"volumeId": volume_id}) as lookup_resp:
+                        if lookup_resp.status != 200:
+                            return None
+                        data = await lookup_resp.json()
+
+                    locations = data.get("locations") or []
+                    if not locations:
                         return None
-                    data = await lookup_resp.json()
-                locations = data.get("locations")
 
-                if not locations:
-                    return None
+                    # 2. 依次尝试可用的 Volume 节点
+                    for loc in locations:
+                        raw_pub = loc.get("publicUrl") or loc.get("url")
+                        if not raw_pub:
+                            continue
+                        file_url = cls.resolve_volume_url(raw_pub, fid)
+
+                        try:
+                            async with client.get(file_url) as file_resp:
+                                if file_resp.status == 200:
+                                    content = await file_resp.read()
+                                    mime = file_resp.headers.get("Content-Type", "application/octet-stream")
+                                    return (content, mime)
+                        except Exception as node_err:
+                            logger.warning(f"[SeaweedFS] Failed to fetch from node {file_url}: {node_err}")
+                            continue
 
-                # 2️⃣ 直接请求 Volume Server
-                # 同样直接使用 Docker 内部地址
-                public_url = locations[0]["publicUrl"]
-                file_url = f"http://{public_url}/{fid}"
+                    return None
 
-                async with client.get(file_url) as file_resp:
-                    if file_resp.status == 200:
-                        content = await file_resp.read()
-                        return (
-                            content,
-                            file_resp.headers.get("Content-Type", "application/octet-stream"),
-                        )
+            except Exception as e:
+                if attempt == max_retries:
+                    logger.warning(f"[SeaweedFS] Get failed for fid {fid}: {e}")
+                    return None
+                await asyncio.sleep(0.3)
 
-                return None
-
-        except Exception as e:
-            logger.exception(f"SeaweedFS get failed for fid {fid}")
-            return None
+        return None
 
     @classmethod
     async def delete(cls, fid: str) -> bool:
         """
         删除文件
         """
-        try:
-            if not fid:
-                return False
+        if not fid:
+            return False
 
-            volume_id = fid.split(",")[0]
+        volume_id = fid.split(",")[0]
+        master_url = cls.get_master_url()
+        timeout = aiohttp.ClientTimeout(total=8.0)
 
-            timeout = aiohttp.ClientTimeout(total=5.0)
+        try:
             async with aiohttp.ClientSession(timeout=timeout) as client:
-                # 1️⃣ 查找位置
-                async with client.get(
-                    f"{cls.MASTER_URL}/dir/lookup",
-                    params={"volumeId": volume_id},
-                ) as lookup_resp:
+                lookup_url = f"{master_url}/dir/lookup"
+                async with client.get(lookup_url, params={"volumeId": volume_id}) as lookup_resp:
                     if lookup_resp.status != 200:
                         return False
                     data = await lookup_resp.json()
-                locations = data.get("locations")
 
+                locations = data.get("locations") or []
                 if not locations:
                     return False
 
-                # 2️⃣ 发送删除请求
-                public_url = locations[0]["publicUrl"]
-                delete_url = f"http://{public_url}/{fid}"
+                public_url = locations[0].get("publicUrl") or locations[0].get("url")
+                if not public_url:
+                    return False
 
+                delete_url = cls.resolve_volume_url(public_url, fid)
                 async with client.delete(delete_url) as del_resp:
-                    # SeaweedFS 删除成功通常返回 200 或 202
-                    return del_resp.status in [200, 202]
+                    return del_resp.status in (200, 202)
 
         except Exception as e:
-            logger.error(f"SeaweedFS delete failed for fid {fid}: {e}")
+            logger.error(f"[SeaweedFS] Delete failed for fid {fid}: {e}")
             return False

+ 139 - 156
app/services/task_handlers.py

@@ -1,8 +1,7 @@
 # app/services/task_handlers.py
 
 import logging
-from datetime import datetime
-from typing import Callable, Awaitable, Dict, Any
+from typing import Callable, Awaitable, Dict, Any, Optional
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
 from redis.asyncio import Redis
@@ -11,20 +10,148 @@ from app.models.user import VasUser
 from app.models.vas_task import VasTask
 from app.models.order import VasOrder
 from app.services.notification_service import NotificationService
-from app.services.email_authorizations_service import EmailAuthorizationService
 
 logger = logging.getLogger(__name__)
 
-# 1. 修改 HandlerFunc 类型签名,增加 redis_client: Redis
 HandlerFunc = Callable[[AsyncSession, Redis, VasTask, VasOrder], Awaitable[None]]
 
+
+def _parse_routing_key(routing_key: str) -> Dict[str, str]:
+    """
+    解析 routing_key 获取国家、城市、签证类型等基础信息
+    例如: auto.slot.dub.nl.tourist -> city: DUB, country: NL, visa_type: Tourist
+    """
+    info = {}
+    if not routing_key:
+        return info
+    parts = routing_key.split(".")
+    # 支持 auto.slot.<city>.<country>.<visa_type> 或 slot.<city>.<country>.<visa_type>
+    offset = 0
+    if parts and parts[0] == "auto":
+        offset += 1
+    if len(parts) > offset and parts[offset] == "slot":
+        offset += 1
+
+    if len(parts) > offset:
+        info["city"] = parts[offset].upper()
+    if len(parts) > offset + 1:
+        info["country"] = parts[offset + 1].upper()
+    if len(parts) > offset + 2:
+        info["visa_type"] = parts[offset + 2].capitalize()
+    return info
+
+
+async def _get_user_by_id(db: AsyncSession, user_id: int) -> Optional[VasUser]:
+    stmt = select(VasUser).where(VasUser.id == user_id)
+    result = await db.execute(stmt)
+    return result.scalar_one_or_none()
+
+
+async def generic_task_completion_handler(
+    db: AsyncSession,
+    redis_client: Redis,
+    task: VasTask,
+    order: VasOrder
+):
+    """
+    通用任务完成处理函数:
+    直接适配所有类型订单,自动提取订单、任务与用户信息并发送完成通知邮件
+    """
+    task_inputs: Dict[str, Any] = task.user_inputs or {}
+    order_inputs: Dict[str, Any] = order.user_inputs or {}
+    grabbed_history: Dict[str, Any] = task.grabbed_history or {}
+
+    user = await _get_user_by_id(db, order.user_id) if order.user_id else None
+
+    # 1. 解析目标收件人邮箱(优先级:用户输入邮箱 > 订单输入邮箱 > 注册用户邮箱)
+    forward_to = (
+        task_inputs.get("email")
+        or order_inputs.get("email")
+        or (user.email if user else "")
+    )
+
+    if not forward_to:
+        logger.warning(f"[TaskHandler] Task {task.id} (Order {order.id}) completed, but no recipient email found.")
+        return
+
+    # 2. 提取用户名
+    username = (
+        task_inputs.get("first_name")
+        or order_inputs.get("first_name")
+        or task_inputs.get("name")
+        or order_inputs.get("name")
+        or (user.nickname if user and user.nickname else None)
+        or (forward_to.split("@")[0] if forward_to else "Customer")
+    )
+
+    # 3. 解析城市、国家、签证类型等业务信息
+    rk_info = _parse_routing_key(task.routing_key)
+    country = (
+        task_inputs.get("country")
+        or order_inputs.get("country")
+        or rk_info.get("country")
+        or ""
+    )
+    city = (
+        task_inputs.get("city")
+        or task_inputs.get("center")
+        or order_inputs.get("city")
+        or order_inputs.get("center")
+        or rk_info.get("city")
+        or ""
+    )
+    visa_type = (
+        task_inputs.get("visa_type")
+        or order_inputs.get("visa_type")
+        or rk_info.get("visa_type")
+        or "Visa"
+    )
+
+    # 4. 提取预约日期/时间
+    slot_date = (
+        grabbed_history.get("slot_date")
+        or grabbed_history.get("appointment_date")
+        or task_inputs.get("appointment_date")
+        or ""
+    )
+    slot_time = grabbed_history.get("slot_time") or ""
+
+    if slot_date and slot_time:
+        display_date = f"{slot_date} {slot_time}"
+    elif slot_date:
+        display_date = str(slot_date)
+    else:
+        display_date = grabbed_history.get("urn") or "Confirmed"
+
+    # 5. 发送通用预约确认完成邮件通知
+    await NotificationService.post_message(
+        db=db,
+        channel="email",
+        payload={
+            "template_id": "appointment_confirmation",
+            "receiver": forward_to,
+            "payload": {
+                "username": username,
+                "order_id": str(order.id),
+                "country": country,
+                "city": city,
+                "appointment_date": display_date,
+                "visa_type": visa_type,
+                "user_email": forward_to,
+            },
+        },
+    )
+    logger.info(f"✅ [TaskHandler] Sent appointment confirmation notification to {forward_to} for order {order.id}")
+
+
 class TaskHandlerRegistry:
     """
     任务后处理注册表
-    用于管理 routing_key 与处理函数的对应关系
+    支持针对特定 routing_key 自定义处理函数,若未注册则自动使用通用处理函数
     """
     def __init__(self):
         self._handlers: Dict[str, HandlerFunc] = {}
+        self._default_handler: HandlerFunc = generic_task_completion_handler
 
     def register(self, *routing_keys: str):
         def decorator(func: HandlerFunc):
@@ -35,169 +162,25 @@ class TaskHandlerRegistry:
             return func
         return decorator
 
-    # 2. 修改 execute 方法,接收 redis_client
+    def set_default_handler(self, func: HandlerFunc):
+        self._default_handler = func
+
     async def execute(self, routing_key: str, db: AsyncSession, redis_client: Redis, task: VasTask, order: VasOrder):
         """
-        根据 routing_key 查找并执行对应的处理函数
+        执行任务后处理逻辑:优先使用定制 handler,否则回退至通用 handler
         """
-        handler = self._handlers.get(routing_key)
-        
+        handler = self._handlers.get(routing_key) or self._default_handler
+
         if not handler:
-            logger.info(f"ℹ️ [TaskHandler] No handler found for routing_key: {routing_key}, skipping.")
+            logger.info(f"ℹ️ [TaskHandler] No handler available for routing_key: {routing_key}, skipping.")
             return
 
         try:
             logger.info(f"▶️ [TaskHandler] Executing handler '{handler.__name__}' for task {task.id} (key: {routing_key})")
-            
-            # 传递 redis_client 给具体处理函数
             await handler(db, redis_client, task, order)
-            
             logger.info(f"✅ [TaskHandler] Handler '{handler.__name__}' completed successfully.")
-            
         except Exception as e:
             logger.error(f"❌ [TaskHandler] Error executing handler for task {task.id}: {str(e)}", exc_info=True)
-            # await self._record_error(db, task, str(e))
-
-    async def _record_error(self, db: AsyncSession, task: VasTask, error_msg: str):
-        try:
-            meta = dict(task.meta) if task.meta else {}
-            meta["post_process_error"] = error_msg
-            task.meta = meta
-        except Exception:
-            pass
 
 
 task_processor = TaskHandlerRegistry()
-
-
-# =================================================================
-# 具体的处理函数 (Handlers)
-# =================================================================
-
-# 辅助函数:获取用户信息(用于发通知)
-async def _get_user_by_id(db: AsyncSession, user_id: int) -> VasUser:
-    stmt = select(VasUser).where(VasUser.id == user_id)
-    result = await db.execute(stmt)
-    return result.scalar_one_or_none()
-
-
-@task_processor.register("auto.slot.dub.nl.tourist")
-async def forward_vfs_appointment_letter(db: AsyncSession, redis_client: Redis, task: VasTask, order: VasOrder):
-    """
-    VFS (荷兰) 预约信转发及通知
-    """
-    inputs: Dict[str, Any] = task.user_inputs or {}
-    grabbed_history = task.grabbed_history or {}
-    task_config = task.config or {}
-
-    email_account = "hujiarui8@gmail.com"
-    user = await _get_user_by_id(db, order.user_id)
-    forward_to = inputs.get("email") or (user.email if user else "")
-
-    urn = grabbed_history.get("urn", "")
-    
-    sender = "donotreply at vfsglobal.com"
-    recipient = task_config.get('alias_email', "")
-    subject_keywords = inputs.get("subjectKeywords", "Appointment,Confirm")
-    body_keywords = inputs.get("bodyKeywords", f"urn") # VFS 通常用 URN 匹配
-
-    if not email_account or not forward_to:
-        logger.warning(f"Task {task.id} missing inputs.")
-        return
-
-    auth = await EmailAuthorizationService.get_by_email(db, email_account)
-    if not auth:
-        raise ValueError(f"Email auth not found: {email_account}")
-
-    result = await EmailAuthorizationService.forward_first_matching_email2(
-        db=db, auth=auth, forward_to=forward_to, sender=sender, recipient=recipient,
-        subject_keywords=subject_keywords, body_keywords=body_keywords
-    )
-
-    meta = dict(task.meta) if task.meta else {}
-    meta["forward_result"] = result
-    task.meta = meta
-
-    # 发送通知
-    if user and user.email:
-        await NotificationService.post_message(
-            db=db,
-            channel="email",
-            payload={
-                "template_id": "appointment_confirmation",
-                "receiver": user.email,
-                "payload": {
-                    "username": user.nickname or 'consumer',
-                    "order_id": str(order.id),
-                    "country": "Netherlands",
-                    "city": "Dublin",
-                    "appointment_date": "Check attachment", # VFS 可能没有直接的日期在 history
-                    "visa_type": "Tourist",
-                    "user_email": forward_to
-                }
-            },
-        )
-
-
-@task_processor.register("auto.slot.dub.de.tourist")
-async def forward_visametric_appointment_letter(db: AsyncSession, redis_client: Redis, task: VasTask, order: VasOrder):
-    """
-    Visametric (德国) 预约信转发及通知
-    """
-    inputs: Dict[str, Any] = task.user_inputs or {}
-    grabbed_history = task.grabbed_history or {}
-    task_config = task.config or {}
-
-    email_account = "hujiarui8@gmail.com"
-    user = await _get_user_by_id(db, order.user_id)
-    forward_to = inputs.get("email") or (user.email if user else "")
-    
-    first_name = inputs.get('first_name', '')
-    last_name = inputs.get('last_name', '')
-    pnr_number = grabbed_history.get('pnr_number', '')
-    slot_date = grabbed_history.get('slot_date', '') # YYYY-MM-DD
-    slot_time = grabbed_history.get('slot_time', '')
-    
-    sender = "noreply at visametric.com"
-    recipient = task_config.get("alias_email", "")
-    subject_keywords = inputs.get("subjectKeywords", f"{pnr_number},Visametric,Appointment,Request")
-    body_keywords = inputs.get("bodyKeywords", f"{pnr_number},{slot_date},{slot_time},{first_name},{last_name}")
-
-    if not email_account or not forward_to:
-        logger.warning(f"Task {task.id} missing inputs.")
-        return
-
-    auth = await EmailAuthorizationService.get_by_email(db, email_account)
-    if not auth:
-        raise ValueError(f"Email auth not found: {email_account}")
-
-    result = await EmailAuthorizationService.forward_first_matching_email2(
-        db=db, auth=auth, forward_to=forward_to, sender=sender, recipient=recipient,
-        subject_keywords=subject_keywords, body_keywords=body_keywords
-    )
-
-    meta = dict(task.meta) if task.meta else {}
-    meta["forward_result"] = result
-    task.meta = meta
-
-    # 发送通知
-    if user and user.email:
-        display_date = f"{slot_date} {slot_time}" if slot_date else "Confirmed"
-        
-        await NotificationService.post_message(
-            db=db,
-            channel="email",
-            payload={
-                "template_id": "appointment_confirmation",
-                "receiver": user.email,
-                "payload": {
-                    "username": user.nickname or first_name,
-                    "order_id": str(order.id),
-                    "country": "Germany",
-                    "city": "Dublin",
-                    "appointment_date": display_date,
-                    "visa_type": "Tourist",
-                    "user_email": forward_to
-                }
-            },
-        )

+ 80 - 95
app/services/vas_task_service.py

@@ -1,16 +1,16 @@
-# app/services/task_service.py
+# app/services/vas_task_service.py
 
 from datetime import datetime, date, timedelta
 from typing import List, Optional
 
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import func, text, select, or_, and_
-from redis.asyncio import Redis  # 引入 Redis 类型
-
+from redis.asyncio import Redis
 
+from app.core.logger import logger
 from app.utils.search import apply_keyword_search_stmt
 from app.utils.pagination import paginate
-from app.core.biz_exception import NotFoundError,BizLogicError
+from app.core.biz_exception import NotFoundError, BizLogicError
 from app.models.vas_task import VasTask
 from app.models.order import VasOrder
 from app.schemas.vas_task import VasTaskCreate, VasTaskUpdate
@@ -29,10 +29,11 @@ class VasTaskService:
         db.add(rec)
         await db.commit()
         await db.refresh(rec)
+        logger.info(f"📋 [VAS_TASK] Created task: id={rec.id} order_id={rec.order_id} routing_key={rec.routing_key}")
         return rec
     
     @staticmethod
-    async def pop_vas_task(db: AsyncSession, routing_key: str, cooldown_seconds: int = 60):
+    async def pop_vas_task(db: AsyncSession, routing_key: str, cooldown_seconds: int = 60) -> VasTask:
         stmt = (
             select(VasTask)
             .where(VasTask.routing_key == routing_key)
@@ -58,65 +59,19 @@ class VasTaskService:
         task.attempt_count += 1
         task.updated_at = func.utc_timestamp() 
         await db.commit()
-        await db.refresh(task)
+        logger.info(f"🏃 [VAS_TASK] Task popped: id={task.id} routing_key={routing_key} attempt={task.attempt_count}")
         return task
-        
+
     @staticmethod
-    async def get_expiring_tasks(db: AsyncSession, threshold_days: int = 3):
-        """
-        获取即将过期或已过期的活跃任务
-        :param threshold_days: 预警阈值,默认 7 天内到期
-        """
-        # 1. 查出所有活跃任务
+    async def get_task_by_order_id(
+        db: AsyncSession,
+        order_id: str,
+    ) -> List[VasTask]:
         stmt = select(VasTask).where(
-            VasTask.status.in_(['pending', 'running', 'grabbed'])
+            VasTask.order_id == order_id
         )
-        tasks = (await db.execute(stmt)).scalars().all()
-        
-        results = []
-        today = date.today()
-
-        for task in tasks:
-            user_inputs = task.user_inputs or {}
-            end_date_str = user_inputs.get("expected_end_date")
-            
-            # 如果没有截止日期,跳过
-            if not end_date_str:
-                continue
-
-            try:
-                # 解析日期
-                end_date = datetime.strptime(end_date_str, "%Y-%m-%d").date()
-                
-                # 计算剩余天数
-                delta = (end_date - today).days
-                
-                # 筛选条件: 已过期 (delta < 0) 或 即将过期 (delta <= threshold)
-                if delta <= threshold_days:
-                    # 获取客户姓名
-                    first = user_inputs.get("first_name", "")
-                    last = user_inputs.get("last_name", "")
-                    email = user_inputs.get("email", "")
-                    social_media_account = user_inputs.get("social_media_account", "")
-                    full_name = f"{first} {last}".strip() or "未知客户"
-
-                    results.append({
-                        "id": task.id,
-                        "order_id": task.order_id,
-                        "routing_key": task.routing_key,
-                        "status": task.status,
-                        "social_media_account": social_media_account,
-                        "customer_name": full_name,
-                        "expected_end_date": end_date_str,
-                        "email": email,
-                        "days_left": delta
-                    })
-            except ValueError:
-                continue # 日期格式错误则忽略
-
-        # 按剩余天数升序排列 (最急的在前面)
-        results.sort(key=lambda x: x["days_left"])
-        return results
+        result = await db.execute(stmt)
+        return result.scalars().all()
 
     @staticmethod
     async def list_task(
@@ -129,62 +84,90 @@ class VasTaskService:
         size: int = 10,
     ):
         stmt = select(VasTask)
-
         if status:
             stmt = stmt.where(VasTask.status == status)
-
         if routing_key:
             stmt = stmt.where(VasTask.routing_key == routing_key)
-
         if script_version:
             stmt = stmt.where(VasTask.script_version == script_version)
-
         stmt = apply_keyword_search_stmt(
             stmt=stmt,
             model=VasTask,
             keyword=keyword,
-            fields=["order_id", "routing_key", "user_inputs"],
-        )
+            fields=["id", "order_id", "routing_key", "user_inputs", "config", "meta", "grabbed_history"],
+        ).order_by(VasTask.created_at.desc())
+        return await paginate(db, stmt, page, size)
 
-        stmt = stmt.order_by(
-            VasTask.priority.desc(),
-            VasTask.id.asc(),
+    @staticmethod
+    async def get_expiring_tasks(
+        db: AsyncSession,
+        threshold_days: int = 3
+    ) -> List[dict]:
+        """
+        获取即将过期的任务列表
+        """
+        now = datetime.utcnow()
+        threshold_date = now + timedelta(days=threshold_days)
+
+        stmt = select(VasTask).where(
+            VasTask.status == "grabbed",
+            VasTask.grabbed_history.isnot(None)
         )
+        result = await db.execute(stmt)
+        tasks = result.scalars().all()
 
-        return await paginate(db, stmt, page, size)
+        expiring_tasks = []
+        for task in tasks:
+            grabbed_history = task.grabbed_history or {}
+            slot_date_str = grabbed_history.get("slot_date")
+            if not slot_date_str:
+                continue
+
+            try:
+                try:
+                    slot_date = datetime.strptime(slot_date_str, "%Y-%m-%d")
+                except ValueError:
+                    slot_date = datetime.strptime(slot_date_str, "%d/%m/%Y")
+
+                if slot_date <= threshold_date:
+                    days_remaining = (slot_date.date() - now.date()).days
+                    expiring_tasks.append({
+                        "task_id": task.id,
+                        "order_id": task.order_id,
+                        "routing_key": task.routing_key,
+                        "slot_date": slot_date_str,
+                        "slot_time": grabbed_history.get("slot_time"),
+                        "days_remaining": days_remaining,
+                        "days_remaining_display": f"{days_remaining} days" if days_remaining > 0 else "Today/Expired",
+                        "status": task.status
+                    })
+            except (ValueError, TypeError):
+                continue
+
+        expiring_tasks.sort(key=lambda x: x["days_remaining"])
+        return expiring_tasks
 
     @staticmethod
-    async def update(
-        db: AsyncSession,
-        id: int,
-        payload: VasTaskUpdate,
-    ) -> VasTask:
+    async def update(db: AsyncSession, id: int, payload: VasTaskUpdate) -> VasTask:
         stmt = select(VasTask).where(VasTask.id == id)
         result = await db.execute(stmt)
-        obj = result.scalar_one_or_none()
+        rec = result.scalar_one_or_none()
 
-        if not obj:
+        if not rec:
             raise NotFoundError("Task not exist")
 
-        data = payload.dict(exclude_unset=True)
-
-        for key, value in data.items():
-            setattr(obj, key, value)
+        old_status = rec.status
+        if payload.status is not None:
+            rec.status = payload.status
+        if payload.grabbed_history is not None:
+            rec.grabbed_history = payload.grabbed_history
+        if payload.meta is not None:
+            rec.meta = payload.meta
 
         await db.commit()
-        await db.refresh(obj)
-        return obj
-
-    @staticmethod
-    async def get_task_by_order_id(
-        db: AsyncSession,
-        order_id: str,
-    ) -> List[VasTask]:
-        stmt = select(VasTask).where(
-            VasTask.order_id == order_id,
-        )
-        result = await db.execute(stmt)
-        return result.scalars().all()
+        await db.refresh(rec)
+        logger.info(f"🔄 [VAS_TASK] Updated task {id}: status {old_status} -> {rec.status}")
+        return rec
     
     @staticmethod
     async def get_task_by_id(
@@ -212,6 +195,7 @@ class VasTaskService:
         rec.status = "pending"
         await db.commit()
         await db.refresh(rec)
+        logger.info(f"🔁 [VAS_TASK] Returned task {id} to queue (status=pending)")
         return rec
     
     @staticmethod
@@ -226,6 +210,7 @@ class VasTaskService:
         rec.status = "pause"
         await db.commit()
         await db.refresh(rec)
+        logger.info(f"⏸️ [VAS_TASK] Paused task {id} (status=pause)")
         return rec
 
     @staticmethod
@@ -251,5 +236,5 @@ class VasTaskService:
         await task_processor.execute(task.routing_key, db, redis_client, task, order)
         await db.commit()
         await db.refresh(task)
+        logger.info(f"✅ [VAS_TASK] Manually confirmed task {id} and order {order.id} as completed")
         return task
-    

+ 0 - 108
app/services/visametric_service.py

@@ -1,108 +0,0 @@
-import re
-import json
-import time
-import random
-import asyncio
-import aiohttp
-from datetime import datetime, timedelta
-from typing import List, Optional, Tuple, Dict, Any
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, or_, and_
-from redis.asyncio import Redis  # 引入 Redis 类型
-
-from redis.asyncio import Redis
-from starlette.concurrency import run_in_threadpool
-from app.core.biz_exception import NotFoundError, BizLogicError
-from app.models.vas_task import VasTask
-from app.core.logger import logger
-from app.services.email_authorizations_service import EmailAuthorizationService
-
-class VisametricService:
-  
-    @staticmethod
-    async def update_pnr(db: AsyncSession, task_id: int) -> VasTask:
-        stmt = select(VasTask).where(VasTask.id == task_id)
-        result = await db.execute(stmt)
-        task = result.scalar_one_or_none()
-
-        if not task:
-            raise NotFoundError("Task not exist")
-        
-        grabbed_history = task.grabbed_history or {}
-        inputs: Dict[str, Any] = task.user_inputs or {}
-        task_config = task.config or {}
-
-        email_account = "hujiarui8@gmail.com"
-        
-        first_name = inputs.get('first_name', '')
-        last_name = inputs.get('last_name', '')
-        pnr_number = grabbed_history.get('pnr_number', '')
-        slot_date = grabbed_history.get('slot_date', '') # YYYY-MM-DD
-        slot_time = grabbed_history.get('slot_time', '')
-        
-        sender = "noreply at visametric.com"
-        recipient = task_config.get("alias_email", "")
-        subject_keywords = inputs.get("subjectKeywords", f"{pnr_number},Visametric,Appointment,Request")
-        body_keywords = inputs.get("bodyKeywords", f"{pnr_number},{slot_date},{slot_time},{first_name},{last_name}")
-
-        auth = await EmailAuthorizationService.get_by_email(db, email_account)
-        if not auth:
-            raise ValueError(f"Email auth not found: {email_account}")
-
-        email_context = await EmailAuthorizationService.fetch_email_authorizations2(
-            db=db, auth=auth, sender=sender, recipient=recipient,
-            subject_keywords=subject_keywords, body_keywords=body_keywords
-        )
-        
-        pattern = r"SDP[A-Z0-9]+"
-        match = re.search(pattern, email_context)
-        if not match:
-            raise NotFoundError(message="PNR not found")
-        current_history = dict(task.grabbed_history) if task.grabbed_history else {} 
-        current_history['pnr_number'] = str(match.group())
-        task.grabbed_history = current_history
-        await db.commit()
-        await db.refresh(task)
-        return task
-                
-    @staticmethod
-    async def cancel_appointment(db: AsyncSession, redis_client: Redis, task_id: int):
-        stmt = select(VasTask).where(VasTask.id == task_id)
-        result = await db.execute(stmt)
-        task = result.scalar_one_or_none()
-
-        if not task:
-            raise NotFoundError("Task not exist")
-        
-        grabbed_history = task.grabbed_history or {}
-        inputs: Dict[str, Any] = task.user_inputs or {}
-        
-        meta = dict(task.meta) if task.meta else {}
-        
-        first_name = inputs.get('first_name', '')
-        last_name = inputs.get('last_name', '')
-        birthday = inputs.get('birthday', '')
-        passport_no = inputs.get('passport_no', '')
-        pnr_number = grabbed_history.get('pnr_number', '')
-        slot_date = grabbed_history.get('slot_date', '')
-        slot_time = grabbed_history.get('slot_time', '')
-        
-        ss = birthday.split('-')
-        cancel_request = {
-            "passport": passport_no,
-            "birth_day": ss[2],
-            "birth_month": ss[1],
-            "birth_year": ss[0],
-            "pnrcontrolform": pnr_number
-        }
-        print(f'cancel request={cancel_request}')
-        
-        queue_key = "visametric_cancel_person_info"
-        message = json.dumps(cancel_request)
-        await redis_client.lpush(queue_key, message)
-        
-        time_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        meta["cancelled_at"] = time_str
-
-        task.meta = meta
-        await db.commit()

+ 21 - 9
app/services/webhook_service.py

@@ -7,6 +7,7 @@ from decimal import Decimal
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
 
+from app.core.logger import logger
 from app.core.biz_exception import NotFoundError, BizLogicError
 from app.models.order import VasOrder
 from app.models.vas_task import VasTask
@@ -17,6 +18,7 @@ from app.models.payment_qr import VasPaymentQR
 from app.schemas.webhook import SMSHelperWebhookPayload, PaymentWebhookOut
 
 
+
 class WebhookService:
     # =========================================================
     # 内部方法:创建 Task(幂等)
@@ -233,6 +235,8 @@ class WebhookService:
         await db.commit()
         await db.refresh(payment)
 
+        logger.info(f"🔔 [WEBHOOK] SMSHelper matched payment {payment.id} for order {order.id} status={payment.status}")
+
         return PaymentWebhookOut(
             status=True,
             order_id=order.id,
@@ -260,6 +264,7 @@ class WebhookService:
         )
         existed_result = await db.execute(existed_stmt)
         if existed_result.scalar_one_or_none():
+            logger.info(f"🔔 [WEBHOOK] Stripe duplicate event ignored: {event_id}")
             return None
 
         if event_type != "checkout.session.completed":
@@ -268,9 +273,9 @@ class WebhookService:
                     provider="stripe",
                     event_id=event_id,
                     event_type=event_type,
-                    raw_payload=event,  # 修正:payload -> raw_payload
+                    raw_payload=event,
                     created_at=datetime.utcnow(),
-                    status="ignored"    # 补充状态,虽有默认值但明确更好
+                    status="ignored"
                 )
             )
             await db.commit()
@@ -281,6 +286,7 @@ class WebhookService:
         order_id = metadata.get("order_id")
 
         if not payment_id or not order_id:
+            logger.error(f"❌ [WEBHOOK] Missing payment_id or order_id in Stripe metadata for event {event_id}")
             raise BizLogicError("Missing payment_id or order_id in metadata")
 
         pay_stmt = select(VasPayment).where(VasPayment.id == int(payment_id))
@@ -288,6 +294,7 @@ class WebhookService:
         payment = pay_result.scalar_one_or_none()
 
         if not payment:
+            logger.error(f"❌ [WEBHOOK] Stripe payment {payment_id} not found")
             raise NotFoundError("Payment not found")
 
         if payment.status == "succeeded":
@@ -296,19 +303,21 @@ class WebhookService:
                     provider="stripe",
                     event_id=event_id,
                     event_type=event_type,
-                    matched_payment_id=payment.id,  # 修正:payment_id -> matched_payment_id
-                    raw_payload=event,              # 补充:记录 raw_payload
-                    status="duplicate",             # 补充:记录状态
+                    matched_payment_id=payment.id,
+                    raw_payload=event,
+                    status="duplicate",
                     created_at=datetime.utcnow(),
                 )
             )
             await db.commit()
+            logger.info(f"🔔 [WEBHOOK] Stripe payment {payment_id} already succeeded (duplicate event)")
             return None
 
         paid_amount = data["amount_total"]
         paid_currency = data["currency"].upper()
 
         if paid_amount != payment.amount or paid_currency != payment.currency:
+            logger.error(f"❌ [WEBHOOK] Stripe amount mismatch: expected {payment.amount} {payment.currency}, got {paid_amount} {paid_currency}")
             raise BizLogicError(
                 f"Amount mismatch, expected {payment.amount} {payment.currency}, "
                 f"got {paid_amount} {paid_currency}"
@@ -334,10 +343,10 @@ class WebhookService:
                 provider="stripe",
                 event_id=event_id,
                 event_type=event_type,
-                matched_payment_id=payment.id,  # 修正:payment_id -> matched_payment_id
-                matched_order_id=order_id,      # 修正:order_id -> matched_order_id
-                raw_payload=event,              # 修正:payload -> raw_payload
-                status="applied",               # 明确状态
+                matched_payment_id=payment.id,
+                matched_order_id=order_id,
+                raw_payload=event,
+                status="applied",
                 created_at=now,
             )
         )
@@ -345,6 +354,8 @@ class WebhookService:
         await db.commit()
         await db.refresh(payment)
 
+        logger.info(f"🎉 [WEBHOOK] Stripe checkout completed: order={order.id} payment={payment.id} status={payment.status}")
+
         return PaymentWebhookOut(
             status=True,
             order_id=order.id,
@@ -352,3 +363,4 @@ class WebhookService:
             payment_id=payment.id,
             notify=True,
         )
+

+ 12 - 4
docker-compose.yml

@@ -8,7 +8,7 @@ services:
       dockerfile: Dockerfile
     restart: always
     
-    # 端口映射:将容器的 8000 映射到宿主机的 8000
+    # 端口映射:将容器的 8888 映射到宿主机的 8888
     # 绑定到 127.0.0.1 保证安全性,只允许宿主机的 Nginx 访问
     ports:
       - "127.0.0.1:8888:8888"
@@ -18,13 +18,17 @@ services:
       - .env
 
     environment:
-      # 🔴 直接用容器名访问,简单粗暴
       - SEAWEEDFS_MASTER_URL=http://seaweedfs-master:9333
+      - LOG_DIR=/app/logs
+
+    # 持久化日志目录挂载
+    volumes:
+      - ./logs:/app/logs
+
     networks:
       - textskin-net # 加入同一个网络
-    # 不需要 extra_hosts 了,删掉它
 
-  # 新增的消息处理容器 (Iris)
+  # 消息处理容器 (Iris)
   messenger:
     container_name: textskin-messenger
     build:
@@ -37,6 +41,10 @@ services:
       - .env
     environment:
       - SEAWEEDFS_MASTER_URL=http://seaweedfs-master:9333
+      - LOG_DIR=/app/logs
+    # 持久化日志目录挂载
+    volumes:
+      - ./logs:/app/logs
     depends_on:
       - backend
     networks:

+ 2 - 1
requirements.txt

@@ -10,11 +10,12 @@ jsonschema
 asyncmy
 uvicorn[standard]
 sqlalchemy
+greenlet
 pydantic
 pydantic-settings
 pydantic[email]
 psycopg2-binary  # PostgreSQL
-mysqlclient       # MySQL
+pymysql          # MySQL (pure python, cross-platform)
 redis
 httpx
 alembic

+ 412 - 114
scripts/notification_templates.py

@@ -1,3 +1,4 @@
+import html
 from typing import Dict, Tuple, Any, List
 
 # ==========================================
@@ -5,30 +6,53 @@ from typing import Dict, Tuple, Any, List
 # ==========================================
 
 def _format_slot_summary(availability: Any) -> str:
+    """格式化槽位可用日期摘要"""
     if not isinstance(availability, list) or not availability:
         return "No specific time slots recorded."
     items = []
     for day in availability[:4]:
-        date = day.get("date", "")
-        # Minimalist text for anti-spam
-        items.append(f"- {date}")
-    return "\n".join(items)
+        if isinstance(day, dict):
+            date = day.get("date") or ""
+            if date:
+                items.append(f"- {date}")
+        elif isinstance(day, str) and day:
+            items.append(f"- {day}")
+    return "\n".join(items) if items else "No specific time slots recorded."
+
 
 def _format_currency(amount_in_cents: Any) -> str:
-    """将分转换为元,保留两位小数"""
+    """将分转换为元,保留两位小数;若为 None 或空则返回 0.00"""
+    if amount_in_cents is None or amount_in_cents == "":
+        return "0.00"
     try:
-        # 确保是数字类型
         value = float(amount_in_cents) / 100.0
         return f"{value:.2f}"
     except (ValueError, TypeError):
         return str(amount_in_cents)
 
-def _get_status_meta(status: str) -> Tuple[str, str, str]:
-    if status == 'Available':
+
+def _get_status_meta(status: Any, has_earliest_date: bool = False) -> Tuple[str, str, str]:
+    """
+    智能解析状态,忽略大小写,并支持根据最早日期回退
+    """
+    if not status:
+        if has_earliest_date:
+            return "READY", "#16a34a", "Available"
+        return "NONE", "#dc2626", "No Slots"
+
+    s = str(status).strip().lower()
+    if s in ("available", "ready", "ok", "open"):
         return "READY", "#16a34a", "Available"
-    if status == 'Waitlist':
+    if s in ("waitlist", "wait", "pending"):
         return "WAIT", "#ca8a04", "Waitlist Only"
-    return "NONE", "#dc2626", "No Slots"
+    if s in ("none", "unavailable", "closed", "full"):
+        return "NONE", "#dc2626", "No Slots"
+
+    # 若状态未知但有最早日期,默认作为 Available
+    if has_earliest_date:
+        return "READY", "#16a34a", str(status)
+    return "NONE", "#dc2626", str(status)
+
 
 # ==========================================
 # 1. EMAIL TEMPLATES (Anti-Spam Optimized)
@@ -39,6 +63,7 @@ def _email_base(content_html: str, app_name: str = "TextSkin") -> str:
     Ultra-clean HTML structure. 
     Uses standard fonts and minimal CSS to pass through ESP filters.
     """
+    safe_app_name = html.escape(str(app_name or "TextSkin"))
     return f"""
     <!DOCTYPE html>
     <html lang="en">
@@ -65,240 +90,458 @@ def _email_base(content_html: str, app_name: str = "TextSkin") -> str:
                     <hr>
                     <p style="font-size: 13px; color: #888;">
                         Regards,<br>
-                        <strong>{app_name} Team</strong>
+                        <strong>{safe_app_name} Team</strong>
                     </p>
                 </div>
             </div>
             <div class="footer">
-                You received this because you are a registered user of {app_name}.<br>
+                You received this because you are a registered user of {safe_app_name}.<br>
                 To manage your notification settings, please visit our website.<br>
-                © 2026 {app_name}. Support: contact@text.skin
+                © 2026 {safe_app_name}. Support: contact@text.skin
             </div>
         </div>
     </body>
     </html>
     """
 
+
 def template_email_verification_bind(payload: Dict) -> str:
-    # Use neutral language: "Verification code" instead of "URGENT ACTION"
-    html = f"""
+    app_name = payload.get('app_name') or 'TextSkin'
+    code = payload.get('code') or ''
+    expiration_time = payload.get('expiration_time') or '10 minutes'
+
+    html_content = f"""
         <h2 style="font-size: 20px; color: #111;">Email Verification</h2>
-        <p>You requested to link this email address to your {payload.get('app_name', 'TextSkin')} account.</p>
+        <p>You requested to link this email address to your {html.escape(app_name)} account.</p>
         <p>Your verification code is:</p>
-        <div class="code">{payload.get('code')}</div>
-        <p>This code will expire in {payload.get('expiration_time', '10 minutes')}.</p>
+        <div class="code">{html.escape(str(code))}</div>
+        <p>This code will expire in {html.escape(str(expiration_time))}.</p>
         <p>If you did not make this request, you can safely ignore this email.</p>
     """
-    return _email_base(html, payload.get('app_name', 'TextSkin'))
+    return _email_base(html_content, app_name)
+
 
 def template_email_password_reset(payload: Dict) -> str:
-    html = f"""
+    app_name = payload.get('app_name') or 'TextSkin'
+    code = payload.get('code') or ''
+    expiration_time = payload.get('expiration_time') or '10 minutes'
+
+    html_content = f"""
         <h2 style="font-size: 20px; color: #111;">Password Reset Code</h2>
         <p>We received a request to reset your password. Please enter the following code to continue:</p>
-        <div class="code">{payload.get('code')}</div>
-        <p>Valid for {payload.get('expiration_time', '10 minutes')}. For security reasons, do not share this code.</p>
+        <div class="code">{html.escape(str(code))}</div>
+        <p>Valid for {html.escape(str(expiration_time))}. For security reasons, do not share this code.</p>
     """
-    return _email_base(html, payload.get('app_name', 'TextSkin'))
+    return _email_base(html_content, app_name)
+
 
 def template_email_login_credentials(payload: Dict) -> str:
-    html = f"""
+    app_name = payload.get('app_name') or 'TextSkin'
+    username = payload.get('username') or ''
+    password = payload.get('password') or ''
+    login_url = payload.get('login_url') or 'https://text.skin/login'
+
+    html_content = f"""
         <h2 style="font-size: 20px; color: #111;">Your Account Credentials</h2>
         <p>Your account has been successfully created. Here are your temporary login details:</p>
         <table style="width: 100%; background: #f9f9f9; padding: 15px; border-radius: 4px;">
-            <tr><td><strong>User:</strong></td><td>{payload.get('username')}</td></tr>
-            <tr><td><strong>Pass:</strong></td><td><code>{payload.get('password')}</code></td></tr>
+            <tr><td><strong>User:</strong></td><td>{html.escape(str(username))}</td></tr>
+            <tr><td><strong>Pass:</strong></td><td><code>{html.escape(str(password))}</code></td></tr>
         </table>
-        <p><a href="{payload.get('login_url')}" class="button">Log in to your account</a></p>
+        <p style="margin-top: 20px;"><a href="{html.escape(str(login_url))}" class="button">Log in to your account</a></p>
     """
-    return _email_base(html, payload.get('app_name', 'TextSkin'))
+    return _email_base(html_content, app_name)
+
 
 def template_email_slot_subscription(payload: Dict) -> str:
-    # Change "Alert" to "Update" to sound less like spam
-    html = f"""
+    app_name = payload.get('app_name') or 'TextSkin'
+    country = payload.get('country') or ''
+    city = payload.get('city') or ''
+    location = f"{country}, {city}".strip(", ") or "Specified Location"
+    visa_type = payload.get('visa_type') or 'Visa'
+    earliest_date = payload.get('earliest_date') or 'Available now'
+    website = payload.get('website') or '#'
+
+    html_content = f"""
         <h2 style="font-size: 20px; color: #111;">Visa Slot Update</h2>
         <p>This is an automated update regarding your visa slot subscription.</p>
         <div style="border-left: 3px solid #0052cc; padding-left: 15px; margin: 20px 0;">
-            <strong>Location:</strong> {payload.get('country')}, {payload.get('city')}<br>
-            <strong>Visa Type:</strong> {payload.get('visa_type')}<br>
-            <strong>Earliest Date:</strong> <span style="color:#d93025;">{payload.get('earliest_date')}</span>
+            <strong>Location:</strong> {html.escape(location)}<br>
+            <strong>Visa Type:</strong> {html.escape(str(visa_type))}<br>
+            <strong>Earliest Date:</strong> <span style="color:#d93025; font-weight: bold;">{html.escape(str(earliest_date))}</span>
         </div>
-        <p><a href="{payload.get('website')}" class="button">Check Official Website</a></p>
+        <p><a href="{html.escape(str(website))}" class="button">Check Official Website</a></p>
     """
-    return _email_base(html)
+    return _email_base(html_content, app_name)
+
 
 def template_email_appointment_confirmation(payload: Dict) -> str:
     """预约成功确认邮件 (Anti-Spam Optimized)"""
-    html = f"""
+    app_name = payload.get('app_name') or 'TextSkin'
+    username = payload.get('username') or 'Customer'
+    order_id = payload.get('order_id') or 'N/A'
+    country = payload.get('country') or ''
+    city = payload.get('city') or ''
+    location = f"{country}, {city}".strip(", ") or "N/A"
+    visa_type = payload.get('visa_type') or 'N/A'
+    appointment_date = payload.get('appointment_date') or 'Confirmed'
+    user_email = payload.get('user_email') or 'N/A'
+
+    html_content = f"""
         <h2 style="font-size: 20px; color: #111;">Appointment Confirmed</h2>
-        <p>Dear {payload.get('username', 'Customer')},</p>
+        <p>Dear {html.escape(str(username))},</p>
         <p>We are pleased to inform you that your visa appointment has been successfully booked.</p>
         
         <table style="width: 100%; background: #f9f9f9; padding: 15px; border-radius: 4px; border-collapse: separate; border-spacing: 0 10px; text-align: left;">
             <tr>
                 <td style="width: 35%; color: #555;"><strong>Order ID:</strong></td>
-                <td><code>{payload.get('order_id', 'N/A')}</code></td>
+                <td><code>{html.escape(str(order_id))}</code></td>
             </tr>
             <tr>
                 <td style="color: #555;"><strong>Location:</strong></td>
-                <td>{payload.get('country', '')}, {payload.get('city', '')}</td>
+                <td>{html.escape(location)}</td>
             </tr>
             <tr>
                 <td style="color: #555;"><strong>Visa Type:</strong></td>
-                <td>{payload.get('visa_type', 'N/A')}</td>
+                <td>{html.escape(str(visa_type))}</td>
             </tr>
             <tr>
                 <td style="color: #555;"><strong>Appointment Date:</strong></td>
-                <td><strong style="color: #0052cc;">{payload.get('appointment_date', 'N/A')}</strong></td>
+                <td><strong style="color: #0052cc;">{html.escape(str(appointment_date))}</strong></td>
             </tr>
             <tr>
                 <td style="color: #555;"><strong>Account Email:</strong></td>
-                <td>{payload.get('user_email', 'N/A')}</td>
+                <td>{html.escape(str(user_email))}</td>
             </tr>
         </table>
         
         <p>Please ensure you prepare all required documents well in advance of your appointment date. If you have any questions, feel free to contact our support team.</p>
     """
-    return _email_base(html, payload.get('app_name', 'TextSkin'))
+    return _email_base(html_content, app_name)
+
 
 def template_email_order_event_update(payload: Dict) -> str:
-    """
-    Template for visa progress updates. 
-    Focuses on neutral language to ensure inbox delivery.
-    """
-    order_no = payload.get('order_no', 'N/A')
-    summary = payload.get('summary', 'No summary available.')
-    # Neutral subject line used in get_email_meta: "Notification: Visa Appointment Update"
-    
-    html = f"""
+    """订单事件进度更新邮件"""
+    app_name = payload.get('app_name') or 'TextSkin'
+    order_no = payload.get('order_no') or 'N/A'
+    summary = payload.get('summary') or 'No summary available.'
+    dashboard_url = payload.get('dashboard_url') or 'https://text.skin/dashboard'
+
+    html_content = f"""
         <h2 style="font-size: 20px; color: #111;">Visa Appointment Update</h2>
-        <p>We have received a new update regarding your visa process for <strong>Order #{order_no}</strong>.</p>
+        <p>We have received a new update regarding your visa process for <strong>Order #{html.escape(str(order_no))}</strong>.</p>
         
         <div style="border-left: 3px solid #0052cc; padding: 15px; margin: 20px 0; background-color: #f9fafb; border-radius: 0 4px 4px 0;">
             <strong style="color: #555; font-size: 13px; text-transform: uppercase;">Update Summary:</strong><br>
-            <p style="margin-top: 5px; color: #333;">{summary}</p>
+            <p style="margin-top: 5px; color: #333;">{html.escape(str(summary))}</p>
         </div>
         
         <p>For your security and privacy, please log in to your dashboard to view the full message and any relevant documents.</p>
         
         <p style="margin-top: 30px;">
-            <a href="https://text.skin/dashboard" class="button">Access Dashboard</a>
+            <a href="{html.escape(str(dashboard_url))}" class="button">Access Dashboard</a>
         </p>
     """
-    return _email_base(html, "TextSkin")
+    return _email_base(html_content, app_name)
+
+
+def template_email_ticket_created(payload: Dict) -> str:
+    """用户工单创建确认邮件"""
+    app_name = payload.get('app_name') or 'TextSkin'
+    username = payload.get('username') or 'Customer'
+    ticket_id = payload.get('ticket_id') or 'N/A'
+    ticket_type = payload.get('ticket_type') or 'Support'
+    ticket_url = payload.get('ticket_url') or 'https://text.skin/dashboard'
+    created_at = payload.get('created_at') or 'N/A'
+
+    html_content = f"""
+        <h2 style="font-size: 20px; color: #111;">Support Ticket Received</h2>
+        <p>Dear {html.escape(str(username))},</p>
+        <p>Thank you for contacting us. We have received your support request and assigned it <strong>Ticket #{html.escape(str(ticket_id))}</strong>.</p>
+        
+        <table style="width: 100%; background: #f9f9f9; padding: 15px; border-radius: 4px; border-collapse: separate; border-spacing: 0 10px; text-align: left;">
+            <tr>
+                <td style="width: 35%; color: #555;"><strong>Ticket ID:</strong></td>
+                <td><code>#{html.escape(str(ticket_id))}</code></td>
+            </tr>
+            <tr>
+                <td style="color: #555;"><strong>Type:</strong></td>
+                <td>{html.escape(str(ticket_type))}</td>
+            </tr>
+            <tr>
+                <td style="color: #555;"><strong>Created At:</strong></td>
+                <td>{html.escape(str(created_at))}</td>
+            </tr>
+        </table>
+        
+        <p>Our support team will review your inquiry and get back to you as soon as possible.</p>
+        <p style="margin-top: 25px;">
+            <a href="{html.escape(str(ticket_url))}" class="button">View Ticket Details</a>
+        </p>
+    """
+    return _email_base(html_content, app_name)
+
+
+def template_email_payment_confirmed(payload: Dict) -> str:
+    """支付成功通知邮件"""
+    app_name = payload.get('app_name') or 'TextSkin'
+    amount_decimal = _format_currency(payload.get('amount'))
+    currency = payload.get('currency') or 'USD'
+    order_id = payload.get('order_id') or 'N/A'
+    confirmed_at = payload.get('confirmed_at') or 'N/A'
+
+    html_content = f"""
+        <h2 style="font-size: 20px; color: #111;">Payment Receipt</h2>
+        <p>Thank you for your payment. Your order has been confirmed.</p>
+        <table style="width: 100%; background: #f9f9f9; padding: 15px; border-radius: 4px;">
+            <tr><td><strong>Order ID:</strong></td><td>{html.escape(str(order_id))}</td></tr>
+            <tr><td><strong>Amount:</strong></td><td>{html.escape(amount_decimal)} {html.escape(str(currency))}</td></tr>
+            <tr><td><strong>Time:</strong></td><td>{html.escape(str(confirmed_at))}</td></tr>
+        </table>
+        <p style="margin-top: 20px;"><a href="https://text.skin/dashboard" class="button">View Order Status</a></p>
+    """
+    return _email_base(html_content, app_name)
+
 
 # ==========================================
-# 2. WECHAT / TELEGRAM / WHATSAPP (Keeping the styles)
+# 2. WECHAT / TELEGRAM / WHATSAPP TEMPLATES
 # ==========================================
-# [Note: These channels don't have spam filters based on HTML structure, 
-# so we keep the rich formatting we designed previously.]
 
 def template_wechat_payment_confirmed(payload: Dict) -> str:
-    """支付成功通知模板"""
+    """支付成功通知模板 (企业微信 Markdown)"""
     amount_decimal = _format_currency(payload.get('amount'))
+    currency = payload.get('currency') or 'USD'
+    order_id = payload.get('order_id') or 'N/A'
+    user_email = payload.get('user_email') or 'N/A'
+    confirmed_at = payload.get('confirmed_at') or 'N/A'
+
     return (
         f"# ✅ Payment Success\n"
         f"--- \n"
-        f"💰 **Amount:** {amount_decimal} {payload.get('currency')}\n"
-        f"🆔 **Order ID:** `{payload.get('order_id')}`\n"
-        f"📧 **User Account:** {payload.get('user_email')}\n"
-        f"🕒 **Time:** {payload.get('confirmed_at')}\n\n"
+        f"💰 **Amount:** {amount_decimal} {currency}\n"
+        f"🆔 **Order ID:** `{order_id}`\n"
+        f"📧 **User Account:** {user_email}\n"
+        f"🕒 **Time:** {confirmed_at}\n\n"
         f"Your service has been activated. Please stay tuned for further updates."
     )
-    
+
+
 def template_wechat_appointment_confirmation(payload: Dict) -> str:
     """预约成功微信通知 (Markdown)"""
+    username = payload.get('username') or 'Customer'
+    country = payload.get('country') or ''
+    city = payload.get('city') or ''
+    location = f"{country}, {city}".strip(", ") or "N/A"
+    visa_type = payload.get('visa_type') or 'Visa'
+    appointment_date = payload.get('appointment_date') or 'Confirmed'
+    order_id = payload.get('order_id') or 'N/A'
+
     return (
         f"# 🎉 Appointment Confirmed\n"
         f"--- \n"
-        f"👤 **User:** {payload.get('username', 'Customer')}\n"
-        f"📍 **Location:** {payload.get('country')}, {payload.get('city')}\n"
-        f"🛂 **Visa Type:** {payload.get('visa_type')}\n"
-        f"📅 **Date:** `{payload.get('appointment_date')}`\n"
-        f"🆔 **Order ID:** `{payload.get('order_id')}`\n\n"
+        f"👤 **User:** {username}\n"
+        f"📍 **Location:** {location}\n"
+        f"🛂 **Visa Type:** {visa_type}\n"
+        f"📅 **Date:** `{appointment_date}`\n"
+        f"🆔 **Order ID:** `{order_id}`\n\n"
         f"Your appointment is successfully booked. Please prepare your documents."
     )
 
+
 def template_wechat_slot_snapshot(payload: Dict) -> str:
-    emoji, _, status_text = _get_status_meta(payload.get("availability_status"))
+    """Slot 快照与变动微信通知 (Markdown)"""
+    has_date = bool(payload.get("earliest_date"))
+    emoji, _, status_text = _get_status_meta(payload.get("availability_status"), has_earliest_date=has_date)
     summary = _format_slot_summary(payload.get("availability"))
+    country = payload.get('country') or ''
+    city = payload.get('city') or ''
+    location = f"{country} {city}".strip() or "Slot Update"
+    visa_type = payload.get('visa_type') or 'Visa'
+    earliest_date = payload.get('earliest_date') or 'N/A'
+    website = payload.get('website') or '#'
+
     return (
-        f"# {emoji} {payload.get('country')} {payload.get('city')}\n"
-        f"> {status_text} | {payload.get('visa_type')}\n\n"
-        f"📅 **Earliest Date:** `{payload.get('earliest_date', 'N/A')}`\n\n"
+        f"# {emoji} {location}\n"
+        f"> {status_text} | {visa_type}\n\n"
+        f"📅 **Earliest Date:** `{earliest_date}`\n\n"
         f"🔍 **Slots Overview:**\n{summary}\n\n"
-        f"🔗 [Book Now]({payload.get('website', '#')})"
+        f"🔗 [Book Now]({website})"
+    )
+
+
+def template_wechat_order_event_update(payload: Dict) -> str:
+    """订单进展微信通知 (Markdown)"""
+    order_no = payload.get('order_no') or 'N/A'
+    summary = payload.get('summary') or 'New progress update recorded.'
+    return (
+        f"# 🔔 Visa Progress Update\n"
+        f"--- \n"
+        f"🆔 **Order:** `#{order_no}`\n"
+        f"📝 **Summary:** {summary}\n\n"
+        f"🔗 [View Dashboard](https://text.skin/dashboard)"
+    )
+
+
+def template_wechat_ticket_created(payload: Dict) -> str:
+    """工单创建微信通知 (Markdown)"""
+    ticket_id = payload.get('ticket_id') or 'N/A'
+    username = payload.get('username') or 'Customer'
+    ticket_type = payload.get('ticket_type') or 'Support'
+    created_at = payload.get('created_at') or 'N/A'
+
+    return (
+        f"# 🎫 New Support Ticket\n"
+        f"--- \n"
+        f"🆔 **Ticket ID:** `#{ticket_id}`\n"
+        f"👤 **User:** {username}\n"
+        f"🏷️ **Type:** {ticket_type}\n"
+        f"🕒 **Created At:** {created_at}\n\n"
+        f"🔗 [View Ticket]({payload.get('ticket_url') or 'https://text.skin/dashboard'})"
     )
 
+
 def template_telegram_slot_snapshot(payload: Dict) -> str:
-    emoji, _, status_text = _get_status_meta(payload.get("availability_status"))
+    """Slot 快照 TG 通知 (HTML)"""
+    has_date = bool(payload.get("earliest_date"))
+    emoji, _, status_text = _get_status_meta(payload.get("availability_status"), has_earliest_date=has_date)
     summary = _format_slot_summary(payload.get("availability"))
+    country = html.escape(str(payload.get('country') or ''))
+    city = html.escape(str(payload.get('city') or ''))
+    location = f"{country}, {city}".strip(", ") or "Slot Update"
+    visa_type = html.escape(str(payload.get('visa_type') or 'Visa'))
+    earliest_date = html.escape(str(payload.get('earliest_date') or 'N/A'))
+    website = html.escape(str(payload.get('website') or '#'))
+
     return (
-        f"{emoji} <b>{payload.get('country')}, {payload.get('city')}</b>\n"
-        f"<i>{status_text} · {payload.get('visa_type')}</i>\n"
+        f"{emoji} <b>{location}</b>\n"
+        f"<i>{html.escape(status_text)} · {visa_type}</i>\n"
         f"──────────────────\n"
-        f"📅 <b>Earliest Date:</b> <code>{payload.get('earliest_date', 'N/A')}</code>\n\n"
-        f"📊 <b>Availability:</b>\n{summary}\n"
+        f"📅 <b>Earliest Date:</b> <code>{earliest_date}</code>\n\n"
+        f"📊 <b>Availability:</b>\n{html.escape(summary)}\n"
         f"──────────────────\n"
-        f"🔗 <a href='{payload.get('website', '#')}'><b>Official Website ➜</b></a>\n\n"
+        f"🔗 <a href='{website}'><b>Official Website ➜</b></a>\n\n"
     )
 
+
 def template_telegram_appointment_confirmation(payload: Dict) -> str:
     """预约成功 TG 通知 (HTML)"""
+    username = html.escape(str(payload.get('username') or 'Customer'))
+    country = html.escape(str(payload.get('country') or ''))
+    city = html.escape(str(payload.get('city') or ''))
+    location = f"{country}, {city}".strip(", ") or "N/A"
+    visa_type = html.escape(str(payload.get('visa_type') or 'Visa'))
+    appointment_date = html.escape(str(payload.get('appointment_date') or 'Confirmed'))
+    order_id = html.escape(str(payload.get('order_id') or 'N/A'))
+    user_email = html.escape(str(payload.get('user_email') or 'N/A'))
+
     return (
         f"🎉 <b>Appointment Confirmed</b>\n"
         f"──────────────────\n"
-        f"👤 <b>Name:</b> {payload.get('username', 'Customer')}\n"
-        f"📍 <b>Location:</b> {payload.get('country')}, {payload.get('city')}\n"
-        f"🛂 <b>Visa Type:</b> {payload.get('visa_type')}\n"
-        f"📅 <b>Date:</b> <code>{payload.get('appointment_date')}</code>\n"
+        f"👤 <b>Name:</b> {username}\n"
+        f"📍 <b>Location:</b> {location}\n"
+        f"🛂 <b>Visa Type:</b> {visa_type}\n"
+        f"📅 <b>Date:</b> <code>{appointment_date}</code>\n"
         f"──────────────────\n"
-        f"🆔 <i>Order: {payload.get('order_id')}</i>\n"
-        f"📧 <i>Email: {payload.get('user_email')}</i>"
+        f"🆔 <i>Order: {order_id}</i>\n"
+        f"📧 <i>Email: {user_email}</i>"
     )
-    
+
+
 def template_telegram_order_event_update(payload: Dict) -> str:
-    summary = payload.get('summary', 'New status update received.')
+    """订单进展 TG 通知 (HTML)"""
+    summary = html.escape(str(payload.get('summary') or 'New status update received.'))
+    order_no = html.escape(str(payload.get('order_no') or 'N/A'))
+
     return (
         f"🔔 <b>Visa Progress Update</b>\n"
         f"──────────────────\n"
-        f"🆔 <b>Order:</b> #{payload.get('order_no')}\n"
+        f"🆔 <b>Order:</b> #{order_no}\n"
         f"📊 <b>Summary:</b>\n<i>{summary}</i>\n"
         f"──────────────────\n"
         f"🔗 <a href='https://text.skin/dashboard'><b>View Dashboard ➜</b></a>"
     )
 
+
+def template_telegram_payment_confirmed(payload: Dict) -> str:
+    """支付成功 TG 通知 (HTML)"""
+    amount_decimal = html.escape(_format_currency(payload.get('amount')))
+    currency = html.escape(str(payload.get('currency') or 'USD'))
+    order_id = html.escape(str(payload.get('order_id') or 'N/A'))
+
+    return (
+        f"✅ <b>Payment Received</b>\n"
+        f"──────────────────\n"
+        f"💰 <b>Amount:</b> {amount_decimal} {currency}\n"
+        f"🆔 <b>Order:</b> #{order_id}\n"
+        f"──────────────────\n"
+        f"🔗 <a href='https://text.skin/dashboard'><b>Dashboard ➜</b></a>"
+    )
+
+
+def template_telegram_ticket_created(payload: Dict) -> str:
+    """工单创建 TG 通知 (HTML)"""
+    ticket_id = html.escape(str(payload.get('ticket_id') or 'N/A'))
+    ticket_type = html.escape(str(payload.get('ticket_type') or 'Support'))
+    username = html.escape(str(payload.get('username') or 'Customer'))
+
+    return (
+        f"🎫 <b>Support Ticket #{ticket_id}</b>\n"
+        f"──────────────────\n"
+        f"👤 <b>User:</b> {username}\n"
+        f"🏷️ <b>Type:</b> {ticket_type}\n"
+        f"──────────────────\n"
+        f"🔗 <a href='https://text.skin/dashboard'><b>View Details ➜</b></a>"
+    )
+
+
 def template_whatsapp_slot_snapshot(payload: Dict) -> str:
-    emoji, _, _ = _get_status_meta(payload.get("availability_status"))
+    """Slot 快照 WhatsApp 通知 (Clean Text)"""
+    has_date = bool(payload.get("earliest_date"))
+    emoji, _, _ = _get_status_meta(payload.get("availability_status"), has_earliest_date=has_date)
+    country = payload.get('country') or ''
+    city = payload.get('city') or ''
+    location = f"{country}, {city}".strip(", ") or "Specified Location"
+    visa_type = payload.get('visa_type') or 'Visa'
+    earliest_date = payload.get('earliest_date') or 'Available now'
+    website = payload.get('website') or '#'
+
     return (
         f"{emoji} *VISA SLOT UPDATE*\n\n"
-        f"📍 *Location:* {payload.get('country')}, {payload.get('city')}\n"
-        f"🛂 *Type:* {payload.get('visa_type')}\n"
-        f"📅 *Earliest:* {payload.get('earliest_date')}\n\n"
-        f"🌐 *Book Now:* {payload.get('website')}"
+        f"📍 *Location:* {location}\n"
+        f"🛂 *Type:* {visa_type}\n"
+        f"📅 *Earliest:* {earliest_date}\n\n"
+        f"🌐 *Book Now:* {website}"
     )
-    
+
+
 def template_whatsapp_appointment_confirmation(payload: Dict) -> str:
     """预约成功 WhatsApp 通知 (Clean Text)"""
+    username = payload.get('username') or 'Customer'
+    country = payload.get('country') or ''
+    city = payload.get('city') or ''
+    location = f"{country}, {city}".strip(", ") or "N/A"
+    visa_type = payload.get('visa_type') or 'Visa'
+    appointment_date = payload.get('appointment_date') or 'Confirmed'
+    order_id = payload.get('order_id') or 'N/A'
+
     return (
         f"✅ *APPOINTMENT CONFIRMED*\n\n"
-        f"Dear {payload.get('username', 'Customer')},\n"
+        f"Dear {username},\n"
         f"Your visa appointment has been successfully booked.\n\n"
-        f"📍 *Location:* {payload.get('country')}, {payload.get('city')}\n"
-        f"🛂 *Visa Type:* {payload.get('visa_type')}\n"
-        f"📅 *Date:* {payload.get('appointment_date')}\n"
-        f"🆔 *Order ID:* {payload.get('order_id')}\n\n"
+        f"📍 *Location:* {location}\n"
+        f"🛂 *Visa Type:* {visa_type}\n"
+        f"📅 *Date:* {appointment_date}\n"
+        f"🆔 *Order ID:* {order_id}\n\n"
         f"Please ensure all required documents are prepared. Thank you for choosing TextSkin."
     )
-    
+
+
 def template_whatsapp_order_event_update(payload: Dict) -> str:
-    """
-    WhatsApp template for progress updates.
-    """
-    order_no = payload.get('order_no', 'N/A')
-    # If the service pre-generated a message, use it, otherwise build one
+    """WhatsApp 进展通知"""
+    order_no = payload.get('order_no') or 'N/A'
     message = payload.get('message')
     if not message:
-        summary = payload.get('summary', 'New status update received.')
+        summary = payload.get('summary') or 'New status update received.'
         message = (
             f"🔔 *VISA PROGRESS UPDATE*\n\n"
             f"Order: #{order_no}\n\n"
@@ -308,8 +551,34 @@ def template_whatsapp_order_event_update(payload: Dict) -> str:
         )
     return message
 
+
+def template_whatsapp_payment_confirmed(payload: Dict) -> str:
+    """支付成功 WhatsApp 通知"""
+    amount_decimal = _format_currency(payload.get('amount'))
+    currency = payload.get('currency') or 'USD'
+    order_id = payload.get('order_id') or 'N/A'
+    return (
+        f"✅ *PAYMENT RECEIVED*\n\n"
+        f"Order: #{order_id}\n"
+        f"Amount: {amount_decimal} {currency}\n\n"
+        f"Your service is active. Thank you!"
+    )
+
+
+def template_whatsapp_ticket_created(payload: Dict) -> str:
+    """工单创建 WhatsApp 通知"""
+    ticket_id = payload.get('ticket_id') or 'N/A'
+    ticket_type = payload.get('ticket_type') or 'Support'
+    return (
+        f"🎫 *SUPPORT TICKET CREATED*\n\n"
+        f"Ticket ID: #{ticket_id}\n"
+        f"Type: {ticket_type}\n\n"
+        f"Our team will contact you shortly."
+    )
+
+
 # ==========================================
-# Dispatchers (保持不变)
+# 3. Dispatchers & Maps
 # ==========================================
 
 EMAIL_MAP = {
@@ -319,12 +588,19 @@ EMAIL_MAP = {
     "slot_subscription": (template_email_slot_subscription, "Update: Visa availability change"),
     "appointment_confirmation": (template_email_appointment_confirmation, "Your Visa Appointment Confirmation"),
     "order_event_update": (template_email_order_event_update, "Notification: Visa Appointment Update"),
+    "ticket_created": (template_email_ticket_created, "Support Ticket Received"),
+    "payment_user_confirmed": (template_email_payment_confirmed, "Payment Confirmation Receipt"),
+    "payment_confirmed": (template_email_payment_confirmed, "Payment Confirmation Receipt"),
 }
 
 WECHAT_MAP = {
     "slot_snapshot": template_wechat_slot_snapshot,
+    "slot_subscription": template_wechat_slot_snapshot,
     "payment_user_confirmed": template_wechat_payment_confirmed,
+    "payment_confirmed": template_wechat_payment_confirmed,
     "appointment_confirmation": template_wechat_appointment_confirmation,
+    "order_event_update": template_wechat_order_event_update,
+    "ticket_created": template_wechat_ticket_created,
 }
 
 WHATSAPP_MAP = {
@@ -332,26 +608,48 @@ WHATSAPP_MAP = {
     "slot_snapshot": template_whatsapp_slot_snapshot,
     "appointment_confirmation": template_whatsapp_appointment_confirmation,
     "order_event_update": template_whatsapp_order_event_update,
+    "ticket_created": template_whatsapp_ticket_created,
+    "payment_user_confirmed": template_whatsapp_payment_confirmed,
+    "payment_confirmed": template_whatsapp_payment_confirmed,
 }
 
 TELEGRAM_MAP = {
     "slot_snapshot": template_telegram_slot_snapshot,
+    "slot_subscription": template_telegram_slot_snapshot,
     "appointment_confirmation": template_telegram_appointment_confirmation,
     "order_event_update": template_telegram_order_event_update,
+    "ticket_created": template_telegram_ticket_created,
+    "payment_user_confirmed": template_telegram_payment_confirmed,
+    "payment_confirmed": template_telegram_payment_confirmed,
 }
 
+
 def render_email(tid: str, payload: Dict) -> str:
-    return EMAIL_MAP[tid][0](payload) if tid in EMAIL_MAP else "Notification from TextSkin"
+    if tid in EMAIL_MAP:
+        return EMAIL_MAP[tid][0](payload)
+    return _email_base(f"<p>{html.escape(str(payload))}</p>")
+
 
 def get_email_meta(tid: str) -> Tuple[str, str]:
     sender = "hujiarui8@gmail.com"
-    return (sender, EMAIL_MAP[tid][1]) if tid in EMAIL_MAP else (sender, "Notification")
+    if tid in EMAIL_MAP:
+        return (sender, EMAIL_MAP[tid][1])
+    return (sender, "Notification")
+
 
 def render_wechat_markdown(tid: str, payload: Dict) -> str:
-    return WECHAT_MAP[tid](payload) if tid in WECHAT_MAP else str(payload)
+    if tid in WECHAT_MAP:
+        return WECHAT_MAP[tid](payload)
+    return str(payload)
+
 
 def render_whatsapp_text(tid: str, payload: Dict) -> str:
-    return WHATSAPP_MAP[tid](payload) if tid in WHATSAPP_MAP else str(payload)
+    if tid in WHATSAPP_MAP:
+        return WHATSAPP_MAP[tid](payload)
+    return str(payload)
+
 
 def render_telegram_html(tid: str, payload: Dict) -> str:
-    return TELEGRAM_MAP[tid](payload) if tid in TELEGRAM_MAP else str(payload)
+    if tid in TELEGRAM_MAP:
+        return TELEGRAM_MAP[tid](payload)
+    return html.escape(str(payload))