Răsfoiți Sursa

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

jerry 2 luni în urmă
părinte
comite
f395419b74
39 a modificat fișierele cu 2874 adăugiri și 2502 ștergeri
  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()
 public_router = APIRouter()
@@ -98,1308 +27,32 @@ protected_router = APIRouter()
 # 管理员级别路由
 # 管理员级别路由
 admin_required_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
     # Security / API Keys
     # -----------------------
     # -----------------------
-    openai_api_key: str
     stripe_api_key: str
     stripe_api_key: str
     stripe_webhook_secret: str
     stripe_webhook_secret: str
     telegram_api_token: str = Field("", description="Telegram bot API token")
     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_api_key: str = Field("", description="Whatsapp API key")
     whatsapp_session: str = Field("default", description="Whatsapp session")
     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(
     model_config = SettingsConfigDict(
         env_file=".env",
         env_file=".env",
         env_file_encoding="utf-8",
         env_file_encoding="utf-8",
         case_sensitive=False,
         case_sensitive=False,
+        extra="ignore",
     )
     )
 
 
 
 
+
 @lru_cache
 @lru_cache
 def get_settings() -> Settings:
 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)
 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"
 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 = logging.getLogger("app")
-logger.setLevel(logging.INFO)  # 可改为 DEBUG
+logger.setLevel(logging.INFO)
 
 
-# 防止重复添加 handler
 if not logger.handlers:
 if not logger.handlers:
-    # 控制台输出
+    # 1. 控制台输出
     console_handler = logging.StreamHandler()
     console_handler = logging.StreamHandler()
     console_handler.setLevel(logging.INFO)
     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.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 fastapi.exceptions import RequestValidationError
 from starlette.exceptions import HTTPException as StarletteHTTPException
 from starlette.exceptions import HTTPException as StarletteHTTPException
 
 
+import time
 from app.api import router
 from app.api import router
 from app.core.database import AsyncSessionLocal
 from app.core.database import AsyncSessionLocal
 from app.core.auth import RoleLevel, require_min_role
 from app.core.auth import RoleLevel, require_min_role
 from app.core.config import settings
 from app.core.config import settings
 from app.core.payment import init_stripe
 from app.core.payment import init_stripe
 from app.core.biz_exception import BizException
 from app.core.biz_exception import BizException
-from app.core.logger import logger
+from app.core.logger import logger, access_logger
 
 
 
 
 @asynccontextmanager
 @asynccontextmanager
@@ -26,11 +27,49 @@ async def lifespan(app: FastAPI):
 app = FastAPI(title=settings.app_name, lifespan=lifespan)
 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
 # Exception Handlers
 # -----------------------
 # -----------------------
 @app.exception_handler(BizException)
 @app.exception_handler(BizException)
 async def biz_exception_handler(request: Request, exc: 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(
     return JSONResponse(
         status_code=exc.http_status,
         status_code=exc.http_status,
         content={
         content={
@@ -43,7 +82,11 @@ async def biz_exception_handler(request: Request, exc: BizException):
 
 
 @app.exception_handler(Exception)
 @app.exception_handler(Exception)
 async def unhandled_exception_handler(request: Request, exc: 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(
     return JSONResponse(
         status_code=500,
         status_code=500,
@@ -54,6 +97,7 @@ async def unhandled_exception_handler(request: Request, exc: Exception):
         },
         },
     )
     )
 
 
+
 @app.exception_handler(RequestValidationError)
 @app.exception_handler(RequestValidationError)
 async def validation_exception_handler(request: Request, exc: 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):
 class ParseUserInputsPayload(BaseModel):
     input_raw_str: str
     input_raw_str: str
     schema_id: int
     schema_id: int
+    model: Optional[str] = None
     
     
 class ParseUserInputsOut(BaseModel):
 class ParseUserInputsOut(BaseModel):
     parsed_obj: Optional[Dict[str, Any]]
     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 sqlalchemy.ext.asyncio import AsyncSession
 from redis.asyncio import Redis
 from redis.asyncio import Redis
 
 
+from app.core.logger import logger
 from app.core.biz_exception import (
 from app.core.biz_exception import (
     NotFoundError,
     NotFoundError,
     PermissionDeniedError,
     PermissionDeniedError,
@@ -30,6 +31,7 @@ from app.schemas.auth import (
 from app.services.notification_service import NotificationService
 from app.services.notification_service import NotificationService
 
 
 
 
+
 def _random_password(length: int = 16) -> str:
 def _random_password(length: int = 16) -> str:
     return "".join(
     return "".join(
         random.choices(
         random.choices(
@@ -92,6 +94,7 @@ class AuthService:
         await db.commit()
         await db.commit()
         await db.refresh(user)
         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}
         return {"user": user, "token": token}
 
 
     # =========================
     # =========================
@@ -113,6 +116,7 @@ class AuthService:
         db.add(record)
         db.add(record)
         await db.commit()
         await db.commit()
 
 
+        logger.info(f"📧 [AUTH] Sent bind code to {payload.email} for user={auth_user.id}")
         await NotificationService.post_message(
         await NotificationService.post_message(
             db=db,
             db=db,
             channel="email",
             channel="email",
@@ -143,6 +147,7 @@ class AuthService:
         user = (await db.execute(stmt)).scalar_one_or_none()
         user = (await db.execute(stmt)).scalar_one_or_none()
 
 
         if not user:
         if not user:
+            logger.warning(f"⚠️ [AUTH] Password reset requested for non-existent or unverified email: {payload.email}")
             raise BizLogicError("User not exist")
             raise BizLogicError("User not exist")
 
 
         expiration_time = datetime.utcnow() + timedelta(minutes=10)
         expiration_time = datetime.utcnow() + timedelta(minutes=10)
@@ -154,6 +159,7 @@ class AuthService:
         db.add(record)
         db.add(record)
         await db.commit()
         await db.commit()
 
 
+        logger.info(f"📧 [AUTH] Sent reset password code to {payload.email} for user={user.id}")
         await NotificationService.post_message(
         await NotificationService.post_message(
             db=db,
             db=db,
             channel="email",
             channel="email",
@@ -186,6 +192,7 @@ class AuthService:
             VasUser.email_verified == 1,
             VasUser.email_verified == 1,
         )
         )
         if (await db.execute(stmt)).scalar_one_or_none():
         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")
             raise BizLogicError("Email already bound")
 
 
         # 校验验证码
         # 校验验证码
@@ -195,9 +202,11 @@ class AuthService:
         )
         )
         record = (await db.execute(stmt)).scalar_one_or_none()
         record = (await db.execute(stmt)).scalar_one_or_none()
         if not record:
         if not record:
+            logger.warning(f"⚠️ [AUTH] Invalid bind token for email {payload.email}")
             raise BizLogicError("Token invalid")
             raise BizLogicError("Token invalid")
 
 
         if record.expire_at < datetime.utcnow():
         if record.expire_at < datetime.utcnow():
+            logger.warning(f"⚠️ [AUTH] Expired bind token for email {payload.email}")
             raise BizLogicError("Token expired")
             raise BizLogicError("Token expired")
 
 
         user = await db.get(VasUser, auth_user.id)
         user = await db.get(VasUser, auth_user.id)
@@ -225,6 +234,8 @@ class AuthService:
 
 
         await db.commit()
         await db.commit()
         await db.refresh(user)
         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(
         await NotificationService.post_message(
             db=db,
             db=db,
@@ -257,6 +268,7 @@ class AuthService:
         )
         )
         user = (await db.execute(stmt)).scalar_one_or_none()
         user = (await db.execute(stmt)).scalar_one_or_none()
         if not user:
         if not user:
+            logger.warning(f"⚠️ [AUTH] Password reset attempt on non-existent email: {payload.email}")
             raise BizLogicError("User not exist")
             raise BizLogicError("User not exist")
 
 
         stmt = select(VasVerificationToken).where(
         stmt = select(VasVerificationToken).where(
@@ -265,9 +277,11 @@ class AuthService:
         )
         )
         record = (await db.execute(stmt)).scalar_one_or_none()
         record = (await db.execute(stmt)).scalar_one_or_none()
         if not record:
         if not record:
+            logger.warning(f"⚠️ [AUTH] Password reset invalid token for {payload.email}")
             raise BizLogicError("Token invalid")
             raise BizLogicError("Token invalid")
 
 
         if record.expire_at < datetime.utcnow():
         if record.expire_at < datetime.utcnow():
+            logger.warning(f"⚠️ [AUTH] Password reset token expired for {payload.email}")
             raise BizLogicError("Token expired")
             raise BizLogicError("Token expired")
 
 
         user.password_hash = bcrypt.hashpw(
         user.password_hash = bcrypt.hashpw(
@@ -277,6 +291,7 @@ class AuthService:
         record.used = 1
         record.used = 1
 
 
         await db.commit()
         await db.commit()
+        logger.info(f"🔑 [AUTH] Password reset successful for user={user.id} email={user.email}")
         return True
         return True
 
 
     # =========================
     # =========================
@@ -292,12 +307,14 @@ class AuthService:
         stmt = select(VasUser).where(VasUser.email == req.email)
         stmt = select(VasUser).where(VasUser.email == req.email)
         user = (await db.execute(stmt)).scalar_one_or_none()
         user = (await db.execute(stmt)).scalar_one_or_none()
         if not user:
         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")
             raise NotFoundError("User not found")
 
 
         if not bcrypt.checkpw(
         if not bcrypt.checkpw(
             req.password.encode(),
             req.password.encode(),
             user.password_hash.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")
             raise PermissionDeniedError("Password incorrect")
 
 
         token = "tok_" + uuid.uuid4().hex
         token = "tok_" + uuid.uuid4().hex
@@ -311,4 +328,6 @@ class AuthService:
         db.add(session)
         db.add(session)
         await db.commit()
         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}
         return {"user": user, "token": token}
+

+ 11 - 94
app/services/emails_service.py

@@ -1,18 +1,14 @@
 import re
 import re
-import asyncio
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select, func
 from sqlalchemy import select, func
 from app.core.logger import logger
 from app.core.logger import logger
 from app.schemas.order_event import VasOrderEventCreate
 from app.schemas.order_event import VasOrderEventCreate
 from app.services.order_event_service import OrderEventService
 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.models.emails import VasEmail
 from app.schemas.emails import VasEmailCreate
 from app.schemas.emails import VasEmailCreate
 
 
 class EmailsService:
 class EmailsService:
-    # 关键词黑名单:匹配到这些词的邮件不会创建订单事件,也不会通知用户
+    # 关键词黑名单:匹配到这些词的邮件不会创建订单事件
     SUBJECT_BLACKLIST = [
     SUBJECT_BLACKLIST = [
         "验证码",
         "验证码",
         "动态码",
         "动态码",
@@ -67,8 +63,8 @@ class EmailsService:
         )
         )
         db.add(rec)
         db.add(rec)
         
         
-        # 3. 拦截、匹配订单并入库通知 (此时还在同一个事务中)
-        await EmailsService._intercept_and_notify(db, rec)
+        # 3. 拦截、匹配订单并创建订单事件 (此时还在同一个事务中)
+        await EmailsService._intercept(db, rec)
         
         
         # 4. 统一提交
         # 4. 统一提交
         await db.commit()
         await db.commit()
@@ -82,23 +78,21 @@ class EmailsService:
         return await db.scalar(stmt) or 0
         return await db.scalar(stmt) or 0
 
 
     @staticmethod
     @staticmethod
-    async def _intercept_and_notify(db: AsyncSession, rec: VasEmail) -> None:
+    async def _intercept(db: AsyncSession, rec: VasEmail) -> None:
         """
         """
         拦截处理逻辑:
         拦截处理逻辑:
         1. 黑名单过滤
         1. 黑名单过滤
         2. 创建订单事件 (OrderEventService)
         2. 创建订单事件 (OrderEventService)
-        3. 获取订单关联的用户联系方式
-        4. post_message 到通知表
         """
         """
         if EmailsService._is_subject_blacklisted(rec.subject or ""):
         if EmailsService._is_subject_blacklisted(rec.subject or ""):
             logger.info(f"Email {rec.uid} skipped: subject '{rec.subject}' is in blacklist.")
             logger.info(f"Email {rec.uid} skipped: subject '{rec.subject}' is in blacklist.")
             return
             return
         
         
         if EmailsService._is_sender_blacklisted(rec.sender or ""):
         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
             return
 
 
-        # 1. 尝试创建订单事件 (OrderEventService 内部会根据 rec.recipient 匹配订单)
+        # 尝试创建订单事件 (OrderEventService 内部会根据 rec.recipient 匹配订单)
         try:
         try:
             event = await OrderEventService.create(
             event = await OrderEventService.create(
                 db,
                 db,
@@ -111,87 +105,10 @@ class EmailsService:
                     event_time=None,
                     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:
         except Exception as e:
             logger.warning(f"Failed to create order event for email {rec.uid}: {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 asyncio
 import json
 import json
 import os
 import os
+import re
+from typing import Optional, Dict, Any
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
 from sqlalchemy import select
 from app.core.config import settings
 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.schemas.llm import ParseUserInputsPayload, ParseUserInputsOut
 from app.models.schema import VasSchema
 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:
 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)
         stmt = select(VasSchema).where(VasSchema.id == payload.schema_id)
         obj = (await db.execute(stmt)).scalar_one_or_none()
         obj = (await db.execute(stmt)).scalar_one_or_none()
         if not obj:
         if not obj:
             raise NotFoundError("Schema not exist")
             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 = {
         headers = {
-            "Authorization": f"Bearer {API_KEY}",
-            "Content-Type": "application/json"
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
         }
         }
 
 
         # 构造 Prompt
         # 构造 Prompt
         system_instruction = "You are a specialized data extraction API. Output valid JSON only."
         system_instruction = "You are a specialized data extraction API. Output valid JSON only."
-        
         user_prompt = f"""
         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 = {
         payload = {
-            # "model": "gpt-4o",  # 或 gpt-3.5-turbo
-            "model": "qwen-plus",
+            "model": selected_model,
             "messages": [
             "messages": [
                 {"role": "system", "content": system_instruction},
                 {"role": "system", "content": system_instruction},
                 {"role": "user", "content": user_prompt}
                 {"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.ext.asyncio import AsyncSession
 from sqlalchemy import select
 from sqlalchemy import select
 
 
+from app.core.logger import logger
 from app.utils.search import apply_keyword_search_stmt
 from app.utils.search import apply_keyword_search_stmt
 from app.utils.pagination import paginate
 from app.utils.pagination import paginate
 from app.core.biz_exception import NotFoundError, BizLogicError
 from app.core.biz_exception import NotFoundError, BizLogicError
@@ -54,7 +55,9 @@ class OrderService:
         await db.commit()
         await db.commit()
         await db.refresh(order)
         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
         return order
+
     
     
     @staticmethod
     @staticmethod
     async def cancel(
     async def cancel(
@@ -79,6 +82,7 @@ class OrderService:
             
             
         await db.commit()
         await db.commit()
         await db.refresh(order)
         await db.refresh(order)
+        logger.info(f"🚫 [ORDER] Cancelled order: id={order.id} and its associated tasks")
         return order
         return order
     
     
     @staticmethod
     @staticmethod
@@ -125,6 +129,7 @@ class OrderService:
         
         
         await db.commit()
         await db.commit()
         await db.refresh(order)
         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
         return order
     
     
     @staticmethod
     @staticmethod
@@ -133,12 +138,15 @@ class OrderService:
         order = (await db.execute(stmt)).scalar_one_or_none()
         order = (await db.execute(stmt)).scalar_one_or_none()
 
 
         if not order:
         if not order:
+            logger.warning(f"⚠️ [ORDER] Price adjust failed: Order {order_id} not found")
             raise NotFoundError("Order not exist")
             raise NotFoundError("Order not exist")
 
 
         if order.status != "pending":
         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")
             raise BizLogicError(message="Order not adjustable")
 
 
         # 2. 更新订单价格
         # 2. 更新订单价格
+        old_amount = order.final_amount
         order.adjustment_delta = payload.adjustment_delta
         order.adjustment_delta = payload.adjustment_delta
         order.final_amount = order.base_amount + payload.adjustment_delta
         order.final_amount = order.base_amount + payload.adjustment_delta
 
 
@@ -157,6 +165,7 @@ class OrderService:
 
 
         await db.commit()
         await db.commit()
         await db.refresh(order)
         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
         return order
 
 
     @staticmethod
     @staticmethod
@@ -210,10 +219,10 @@ class OrderService:
         order = (await db.execute(stmt)).scalar_one_or_none()
         order = (await db.execute(stmt)).scalar_one_or_none()
 
 
         if not order:
         if not order:
+            logger.warning(f"⚠️ [ORDER] Patch user_inputs failed: Order {order_id} not found")
             raise NotFoundError("Order not exist")
             raise NotFoundError("Order not exist")
 
 
         order.user_inputs = payload.user_inputs
         order.user_inputs = payload.user_inputs
-        
 
 
         # 1️⃣ 取消旧任务
         # 1️⃣ 取消旧任务
         task_res = await db.execute(
         task_res = await db.execute(
@@ -228,8 +237,9 @@ class OrderService:
         await db.flush()
         await db.flush()
         await WebhookService._create_task_if_not_exists(db, order)
         await WebhookService._create_task_if_not_exists(db, order)
         
         
-        
         await db.commit()
         await db.commit()
         await db.refresh(order)
         await db.refresh(order)
 
 
+        logger.info(f"🔄 [ORDER] Patched user inputs for order {order.id}, recreated tasks")
         return order
         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.ext.asyncio import AsyncSession
 from sqlalchemy import select
 from sqlalchemy import select
 
 
+from app.core.logger import logger
 from app.utils.search import apply_keyword_search_stmt
 from app.utils.search import apply_keyword_search_stmt
 from app.utils.pagination import paginate
 from app.utils.pagination import paginate
 from app.core.biz_exception import NotFoundError, BizLogicError
 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
 from app.services.webhook_service import WebhookService
 
 
 
 
+
 def convert_currency(
 def convert_currency(
     amount: int,
     amount: int,
     from_currency: str,
     from_currency: str,
@@ -192,7 +194,7 @@ class PaymentService:
         payment = (await db.execute(stmt)).scalar_one_or_none()
         payment = (await db.execute(stmt)).scalar_one_or_none()
 
 
         formatted_time = payload.confirmed_at.strftime('%Y-%m-%d %H:%M') + " (UTC)"
         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(
         await NotificationService.post_message(
             db=db,
             db=db,
             channel="wechat",
             channel="wechat",
@@ -230,6 +232,7 @@ class PaymentService:
         record = result.scalar_one_or_none()
         record = result.scalar_one_or_none()
 
 
         if not record:
         if not record:
+            logger.warning(f"⚠️ [PAYMENT] Admin confirm failed: confirmation record {id} not found")
             raise NotFoundError("Payment confirmation record not found")
             raise NotFoundError("Payment confirmation record not found")
 
 
         # 3️⃣ 更新管理员确认状态
         # 3️⃣ 更新管理员确认状态
@@ -241,7 +244,9 @@ class PaymentService:
         await db.commit()
         await db.commit()
         await db.refresh(record)
         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
         return record
+
     
     
     @staticmethod
     @staticmethod
     async def admin_update_status(
     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 os
 import aiohttp
 import aiohttp
+import asyncio
+from typing import Optional, Tuple, Dict, Any
+from urllib.parse import urlparse
 from fastapi import UploadFile
 from fastapi import UploadFile
+from app.core.config import settings
 from app.core.biz_exception import BizLogicError
 from app.core.biz_exception import BizLogicError
 from app.core.logger import logger
 from app.core.logger import logger
 
 
+
 class SeaweedFSService:
 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
     @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:
                         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()
                         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
     @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
                         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
     @classmethod
     async def delete(cls, fid: str) -> bool:
     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:
             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:
                     if lookup_resp.status != 200:
                         return False
                         return False
                     data = await lookup_resp.json()
                     data = await lookup_resp.json()
-                locations = data.get("locations")
 
 
+                locations = data.get("locations") or []
                 if not locations:
                 if not locations:
                     return False
                     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:
                 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:
         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
             return False

+ 139 - 156
app/services/task_handlers.py

@@ -1,8 +1,7 @@
 # app/services/task_handlers.py
 # app/services/task_handlers.py
 
 
 import logging
 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.ext.asyncio import AsyncSession
 from sqlalchemy import select
 from sqlalchemy import select
 from redis.asyncio import Redis
 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.vas_task import VasTask
 from app.models.order import VasOrder
 from app.models.order import VasOrder
 from app.services.notification_service import NotificationService
 from app.services.notification_service import NotificationService
-from app.services.email_authorizations_service import EmailAuthorizationService
 
 
 logger = logging.getLogger(__name__)
 logger = logging.getLogger(__name__)
 
 
-# 1. 修改 HandlerFunc 类型签名,增加 redis_client: Redis
 HandlerFunc = Callable[[AsyncSession, Redis, VasTask, VasOrder], Awaitable[None]]
 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:
 class TaskHandlerRegistry:
     """
     """
     任务后处理注册表
     任务后处理注册表
-    用于管理 routing_key 与处理函数的对应关系
+    支持针对特定 routing_key 自定义处理函数,若未注册则自动使用通用处理函数
     """
     """
     def __init__(self):
     def __init__(self):
         self._handlers: Dict[str, HandlerFunc] = {}
         self._handlers: Dict[str, HandlerFunc] = {}
+        self._default_handler: HandlerFunc = generic_task_completion_handler
 
 
     def register(self, *routing_keys: str):
     def register(self, *routing_keys: str):
         def decorator(func: HandlerFunc):
         def decorator(func: HandlerFunc):
@@ -35,169 +162,25 @@ class TaskHandlerRegistry:
             return func
             return func
         return decorator
         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):
     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:
         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
             return
 
 
         try:
         try:
             logger.info(f"▶️ [TaskHandler] Executing handler '{handler.__name__}' for task {task.id} (key: {routing_key})")
             logger.info(f"▶️ [TaskHandler] Executing handler '{handler.__name__}' for task {task.id} (key: {routing_key})")
-            
-            # 传递 redis_client 给具体处理函数
             await handler(db, redis_client, task, order)
             await handler(db, redis_client, task, order)
-            
             logger.info(f"✅ [TaskHandler] Handler '{handler.__name__}' completed successfully.")
             logger.info(f"✅ [TaskHandler] Handler '{handler.__name__}' completed successfully.")
-            
         except Exception as e:
         except Exception as e:
             logger.error(f"❌ [TaskHandler] Error executing handler for task {task.id}: {str(e)}", exc_info=True)
             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()
 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 datetime import datetime, date, timedelta
 from typing import List, Optional
 from typing import List, Optional
 
 
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import func, text, select, or_, and_
 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.search import apply_keyword_search_stmt
 from app.utils.pagination import paginate
 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.vas_task import VasTask
 from app.models.order import VasOrder
 from app.models.order import VasOrder
 from app.schemas.vas_task import VasTaskCreate, VasTaskUpdate
 from app.schemas.vas_task import VasTaskCreate, VasTaskUpdate
@@ -29,10 +29,11 @@ class VasTaskService:
         db.add(rec)
         db.add(rec)
         await db.commit()
         await db.commit()
         await db.refresh(rec)
         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
         return rec
     
     
     @staticmethod
     @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 = (
         stmt = (
             select(VasTask)
             select(VasTask)
             .where(VasTask.routing_key == routing_key)
             .where(VasTask.routing_key == routing_key)
@@ -58,65 +59,19 @@ class VasTaskService:
         task.attempt_count += 1
         task.attempt_count += 1
         task.updated_at = func.utc_timestamp() 
         task.updated_at = func.utc_timestamp() 
         await db.commit()
         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
         return task
-        
+
     @staticmethod
     @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(
         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
     @staticmethod
     async def list_task(
     async def list_task(
@@ -129,62 +84,90 @@ class VasTaskService:
         size: int = 10,
         size: int = 10,
     ):
     ):
         stmt = select(VasTask)
         stmt = select(VasTask)
-
         if status:
         if status:
             stmt = stmt.where(VasTask.status == status)
             stmt = stmt.where(VasTask.status == status)
-
         if routing_key:
         if routing_key:
             stmt = stmt.where(VasTask.routing_key == routing_key)
             stmt = stmt.where(VasTask.routing_key == routing_key)
-
         if script_version:
         if script_version:
             stmt = stmt.where(VasTask.script_version == script_version)
             stmt = stmt.where(VasTask.script_version == script_version)
-
         stmt = apply_keyword_search_stmt(
         stmt = apply_keyword_search_stmt(
             stmt=stmt,
             stmt=stmt,
             model=VasTask,
             model=VasTask,
             keyword=keyword,
             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
     @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)
         stmt = select(VasTask).where(VasTask.id == id)
         result = await db.execute(stmt)
         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")
             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.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
     @staticmethod
     async def get_task_by_id(
     async def get_task_by_id(
@@ -212,6 +195,7 @@ class VasTaskService:
         rec.status = "pending"
         rec.status = "pending"
         await db.commit()
         await db.commit()
         await db.refresh(rec)
         await db.refresh(rec)
+        logger.info(f"🔁 [VAS_TASK] Returned task {id} to queue (status=pending)")
         return rec
         return rec
     
     
     @staticmethod
     @staticmethod
@@ -226,6 +210,7 @@ class VasTaskService:
         rec.status = "pause"
         rec.status = "pause"
         await db.commit()
         await db.commit()
         await db.refresh(rec)
         await db.refresh(rec)
+        logger.info(f"⏸️ [VAS_TASK] Paused task {id} (status=pause)")
         return rec
         return rec
 
 
     @staticmethod
     @staticmethod
@@ -251,5 +236,5 @@ class VasTaskService:
         await task_processor.execute(task.routing_key, db, redis_client, task, order)
         await task_processor.execute(task.routing_key, db, redis_client, task, order)
         await db.commit()
         await db.commit()
         await db.refresh(task)
         await db.refresh(task)
+        logger.info(f"✅ [VAS_TASK] Manually confirmed task {id} and order {order.id} as completed")
         return task
         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.ext.asyncio import AsyncSession
 from sqlalchemy import select
 from sqlalchemy import select
 
 
+from app.core.logger import logger
 from app.core.biz_exception import NotFoundError, BizLogicError
 from app.core.biz_exception import NotFoundError, BizLogicError
 from app.models.order import VasOrder
 from app.models.order import VasOrder
 from app.models.vas_task import VasTask
 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
 from app.schemas.webhook import SMSHelperWebhookPayload, PaymentWebhookOut
 
 
 
 
+
 class WebhookService:
 class WebhookService:
     # =========================================================
     # =========================================================
     # 内部方法:创建 Task(幂等)
     # 内部方法:创建 Task(幂等)
@@ -233,6 +235,8 @@ class WebhookService:
         await db.commit()
         await db.commit()
         await db.refresh(payment)
         await db.refresh(payment)
 
 
+        logger.info(f"🔔 [WEBHOOK] SMSHelper matched payment {payment.id} for order {order.id} status={payment.status}")
+
         return PaymentWebhookOut(
         return PaymentWebhookOut(
             status=True,
             status=True,
             order_id=order.id,
             order_id=order.id,
@@ -260,6 +264,7 @@ class WebhookService:
         )
         )
         existed_result = await db.execute(existed_stmt)
         existed_result = await db.execute(existed_stmt)
         if existed_result.scalar_one_or_none():
         if existed_result.scalar_one_or_none():
+            logger.info(f"🔔 [WEBHOOK] Stripe duplicate event ignored: {event_id}")
             return None
             return None
 
 
         if event_type != "checkout.session.completed":
         if event_type != "checkout.session.completed":
@@ -268,9 +273,9 @@ class WebhookService:
                     provider="stripe",
                     provider="stripe",
                     event_id=event_id,
                     event_id=event_id,
                     event_type=event_type,
                     event_type=event_type,
-                    raw_payload=event,  # 修正:payload -> raw_payload
+                    raw_payload=event,
                     created_at=datetime.utcnow(),
                     created_at=datetime.utcnow(),
-                    status="ignored"    # 补充状态,虽有默认值但明确更好
+                    status="ignored"
                 )
                 )
             )
             )
             await db.commit()
             await db.commit()
@@ -281,6 +286,7 @@ class WebhookService:
         order_id = metadata.get("order_id")
         order_id = metadata.get("order_id")
 
 
         if not payment_id or not 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")
             raise BizLogicError("Missing payment_id or order_id in metadata")
 
 
         pay_stmt = select(VasPayment).where(VasPayment.id == int(payment_id))
         pay_stmt = select(VasPayment).where(VasPayment.id == int(payment_id))
@@ -288,6 +294,7 @@ class WebhookService:
         payment = pay_result.scalar_one_or_none()
         payment = pay_result.scalar_one_or_none()
 
 
         if not payment:
         if not payment:
+            logger.error(f"❌ [WEBHOOK] Stripe payment {payment_id} not found")
             raise NotFoundError("Payment not found")
             raise NotFoundError("Payment not found")
 
 
         if payment.status == "succeeded":
         if payment.status == "succeeded":
@@ -296,19 +303,21 @@ class WebhookService:
                     provider="stripe",
                     provider="stripe",
                     event_id=event_id,
                     event_id=event_id,
                     event_type=event_type,
                     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(),
                     created_at=datetime.utcnow(),
                 )
                 )
             )
             )
             await db.commit()
             await db.commit()
+            logger.info(f"🔔 [WEBHOOK] Stripe payment {payment_id} already succeeded (duplicate event)")
             return None
             return None
 
 
         paid_amount = data["amount_total"]
         paid_amount = data["amount_total"]
         paid_currency = data["currency"].upper()
         paid_currency = data["currency"].upper()
 
 
         if paid_amount != payment.amount or paid_currency != payment.currency:
         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(
             raise BizLogicError(
                 f"Amount mismatch, expected {payment.amount} {payment.currency}, "
                 f"Amount mismatch, expected {payment.amount} {payment.currency}, "
                 f"got {paid_amount} {paid_currency}"
                 f"got {paid_amount} {paid_currency}"
@@ -334,10 +343,10 @@ class WebhookService:
                 provider="stripe",
                 provider="stripe",
                 event_id=event_id,
                 event_id=event_id,
                 event_type=event_type,
                 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,
                 created_at=now,
             )
             )
         )
         )
@@ -345,6 +354,8 @@ class WebhookService:
         await db.commit()
         await db.commit()
         await db.refresh(payment)
         await db.refresh(payment)
 
 
+        logger.info(f"🎉 [WEBHOOK] Stripe checkout completed: order={order.id} payment={payment.id} status={payment.status}")
+
         return PaymentWebhookOut(
         return PaymentWebhookOut(
             status=True,
             status=True,
             order_id=order.id,
             order_id=order.id,
@@ -352,3 +363,4 @@ class WebhookService:
             payment_id=payment.id,
             payment_id=payment.id,
             notify=True,
             notify=True,
         )
         )
+

+ 12 - 4
docker-compose.yml

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

+ 2 - 1
requirements.txt

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

+ 412 - 114
scripts/notification_templates.py

@@ -1,3 +1,4 @@
+import html
 from typing import Dict, Tuple, Any, List
 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:
 def _format_slot_summary(availability: Any) -> str:
+    """格式化槽位可用日期摘要"""
     if not isinstance(availability, list) or not availability:
     if not isinstance(availability, list) or not availability:
         return "No specific time slots recorded."
         return "No specific time slots recorded."
     items = []
     items = []
     for day in availability[:4]:
     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:
 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:
     try:
-        # 确保是数字类型
         value = float(amount_in_cents) / 100.0
         value = float(amount_in_cents) / 100.0
         return f"{value:.2f}"
         return f"{value:.2f}"
     except (ValueError, TypeError):
     except (ValueError, TypeError):
         return str(amount_in_cents)
         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"
         return "READY", "#16a34a", "Available"
-    if status == 'Waitlist':
+    if s in ("waitlist", "wait", "pending"):
         return "WAIT", "#ca8a04", "Waitlist Only"
         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)
 # 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. 
     Ultra-clean HTML structure. 
     Uses standard fonts and minimal CSS to pass through ESP filters.
     Uses standard fonts and minimal CSS to pass through ESP filters.
     """
     """
+    safe_app_name = html.escape(str(app_name or "TextSkin"))
     return f"""
     return f"""
     <!DOCTYPE html>
     <!DOCTYPE html>
     <html lang="en">
     <html lang="en">
@@ -65,240 +90,458 @@ def _email_base(content_html: str, app_name: str = "TextSkin") -> str:
                     <hr>
                     <hr>
                     <p style="font-size: 13px; color: #888;">
                     <p style="font-size: 13px; color: #888;">
                         Regards,<br>
                         Regards,<br>
-                        <strong>{app_name} Team</strong>
+                        <strong>{safe_app_name} Team</strong>
                     </p>
                     </p>
                 </div>
                 </div>
             </div>
             </div>
             <div class="footer">
             <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>
                 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>
         </div>
         </div>
     </body>
     </body>
     </html>
     </html>
     """
     """
 
 
+
 def template_email_verification_bind(payload: Dict) -> str:
 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>
         <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>
         <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>
         <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:
 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>
         <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>
         <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:
 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>
         <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>
         <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;">
         <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>
         </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:
 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>
         <h2 style="font-size: 20px; color: #111;">Visa Slot Update</h2>
         <p>This is an automated update regarding your visa slot subscription.</p>
         <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;">
         <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>
         </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:
 def template_email_appointment_confirmation(payload: Dict) -> str:
     """预约成功确认邮件 (Anti-Spam Optimized)"""
     """预约成功确认邮件 (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>
         <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>
         <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;">
         <table style="width: 100%; background: #f9f9f9; padding: 15px; border-radius: 4px; border-collapse: separate; border-spacing: 0 10px; text-align: left;">
             <tr>
             <tr>
                 <td style="width: 35%; color: #555;"><strong>Order ID:</strong></td>
                 <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>
             <tr>
             <tr>
                 <td style="color: #555;"><strong>Location:</strong></td>
                 <td style="color: #555;"><strong>Location:</strong></td>
-                <td>{payload.get('country', '')}, {payload.get('city', '')}</td>
+                <td>{html.escape(location)}</td>
             </tr>
             </tr>
             <tr>
             <tr>
                 <td style="color: #555;"><strong>Visa Type:</strong></td>
                 <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>
             <tr>
             <tr>
                 <td style="color: #555;"><strong>Appointment Date:</strong></td>
                 <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>
             <tr>
             <tr>
                 <td style="color: #555;"><strong>Account Email:</strong></td>
                 <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>
             </tr>
         </table>
         </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>
         <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:
 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>
         <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;">
         <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>
             <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>
         </div>
         
         
         <p>For your security and privacy, please log in to your dashboard to view the full message and any relevant documents.</p>
         <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;">
         <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>
         </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:
 def template_wechat_payment_confirmed(payload: Dict) -> str:
-    """支付成功通知模板"""
+    """支付成功通知模板 (企业微信 Markdown)"""
     amount_decimal = _format_currency(payload.get('amount'))
     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 (
     return (
         f"# ✅ Payment Success\n"
         f"# ✅ Payment Success\n"
         f"--- \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."
         f"Your service has been activated. Please stay tuned for further updates."
     )
     )
-    
+
+
 def template_wechat_appointment_confirmation(payload: Dict) -> str:
 def template_wechat_appointment_confirmation(payload: Dict) -> str:
     """预约成功微信通知 (Markdown)"""
     """预约成功微信通知 (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 (
     return (
         f"# 🎉 Appointment Confirmed\n"
         f"# 🎉 Appointment Confirmed\n"
         f"--- \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."
         f"Your appointment is successfully booked. Please prepare your documents."
     )
     )
 
 
+
 def template_wechat_slot_snapshot(payload: Dict) -> str:
 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"))
     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 (
     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"🔍 **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:
 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"))
     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 (
     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"──────────────────\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"──────────────────\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:
 def template_telegram_appointment_confirmation(payload: Dict) -> str:
     """预约成功 TG 通知 (HTML)"""
     """预约成功 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 (
     return (
         f"🎉 <b>Appointment Confirmed</b>\n"
         f"🎉 <b>Appointment Confirmed</b>\n"
         f"──────────────────\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"──────────────────\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:
 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 (
     return (
         f"🔔 <b>Visa Progress Update</b>\n"
         f"🔔 <b>Visa Progress Update</b>\n"
         f"──────────────────\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"📊 <b>Summary:</b>\n<i>{summary}</i>\n"
         f"──────────────────\n"
         f"──────────────────\n"
         f"🔗 <a href='https://text.skin/dashboard'><b>View Dashboard ➜</b></a>"
         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:
 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 (
     return (
         f"{emoji} *VISA SLOT UPDATE*\n\n"
         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:
 def template_whatsapp_appointment_confirmation(payload: Dict) -> str:
     """预约成功 WhatsApp 通知 (Clean Text)"""
     """预约成功 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 (
     return (
         f"✅ *APPOINTMENT CONFIRMED*\n\n"
         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"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."
         f"Please ensure all required documents are prepared. Thank you for choosing TextSkin."
     )
     )
-    
+
+
 def template_whatsapp_order_event_update(payload: Dict) -> str:
 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')
     message = payload.get('message')
     if not message:
     if not message:
-        summary = payload.get('summary', 'New status update received.')
+        summary = payload.get('summary') or 'New status update received.'
         message = (
         message = (
             f"🔔 *VISA PROGRESS UPDATE*\n\n"
             f"🔔 *VISA PROGRESS UPDATE*\n\n"
             f"Order: #{order_no}\n\n"
             f"Order: #{order_no}\n\n"
@@ -308,8 +551,34 @@ def template_whatsapp_order_event_update(payload: Dict) -> str:
         )
         )
     return message
     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 = {
 EMAIL_MAP = {
@@ -319,12 +588,19 @@ EMAIL_MAP = {
     "slot_subscription": (template_email_slot_subscription, "Update: Visa availability change"),
     "slot_subscription": (template_email_slot_subscription, "Update: Visa availability change"),
     "appointment_confirmation": (template_email_appointment_confirmation, "Your Visa Appointment Confirmation"),
     "appointment_confirmation": (template_email_appointment_confirmation, "Your Visa Appointment Confirmation"),
     "order_event_update": (template_email_order_event_update, "Notification: Visa Appointment Update"),
     "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 = {
 WECHAT_MAP = {
     "slot_snapshot": template_wechat_slot_snapshot,
     "slot_snapshot": template_wechat_slot_snapshot,
+    "slot_subscription": template_wechat_slot_snapshot,
     "payment_user_confirmed": template_wechat_payment_confirmed,
     "payment_user_confirmed": template_wechat_payment_confirmed,
+    "payment_confirmed": template_wechat_payment_confirmed,
     "appointment_confirmation": template_wechat_appointment_confirmation,
     "appointment_confirmation": template_wechat_appointment_confirmation,
+    "order_event_update": template_wechat_order_event_update,
+    "ticket_created": template_wechat_ticket_created,
 }
 }
 
 
 WHATSAPP_MAP = {
 WHATSAPP_MAP = {
@@ -332,26 +608,48 @@ WHATSAPP_MAP = {
     "slot_snapshot": template_whatsapp_slot_snapshot,
     "slot_snapshot": template_whatsapp_slot_snapshot,
     "appointment_confirmation": template_whatsapp_appointment_confirmation,
     "appointment_confirmation": template_whatsapp_appointment_confirmation,
     "order_event_update": template_whatsapp_order_event_update,
     "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 = {
 TELEGRAM_MAP = {
     "slot_snapshot": template_telegram_slot_snapshot,
     "slot_snapshot": template_telegram_slot_snapshot,
+    "slot_subscription": template_telegram_slot_snapshot,
     "appointment_confirmation": template_telegram_appointment_confirmation,
     "appointment_confirmation": template_telegram_appointment_confirmation,
     "order_event_update": template_telegram_order_event_update,
     "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:
 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]:
 def get_email_meta(tid: str) -> Tuple[str, str]:
     sender = "hujiarui8@gmail.com"
     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:
 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:
 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:
 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))