feat(huya): 外部 CK 协作台账(S1–S6)+ 图片上传能力

协作台账:新表 huya_external_orders 替代 Excel 多人协同表(设计见
docs/设计-虎牙外部CK协作台账.md),一条 CK 一行,所有人共享、改动留痕。

- 前端 pages/HuyaCollabPage.tsx + 菜单「虎牙 → 外部单协作」/huya/collab:
  内联编辑(带乐观锁 version)、图片缩略图、详情抽屉(字段表单 + 两个图片槽位 +
  操作时间线)、粘贴导入弹窗(带 TSV 预览)、批量/单条验证 CK、页头统计条、筛选
- 两套状态机:业务 pending→bound→recharged→scripted→done(旁路 void)、
  凭据 unverified/valid/invalid/disabled;唯一写入口在 services/huya_collab_service.py,
  字段级审计 + 整数 version 乐观锁(不用 updated_at:DATETIME 只到秒)
- CK 只读探针 check_user_bind_game_account(真机判据:响应非 None 且 status == 200),
  成功即覆盖写绑定快照 bind_game_account/bind_game_role/bind_game_channel(迁移 0056),
  失败只改凭据状态、不动业务状态;人工只能停用/恢复(POST /{id}/ck/status)
- 贴/换/重建 CK、TSV 批量导入(SAVEPOINT 单行隔离,部分失败不整体失败)、
  权限 huya:collab:view/edit/manage(删除只给运营)
- 孤儿图清理脚本 scripts/cleanup_orphan_file_assets.py(默认 --dry-run)

图片上传(协作台账截图用):OSS/本地双后端 + 缩略图变体 + /api/files 代理回读,
权限 file:upload / file:view。

验证:pytest 880 passed / 6 skipped;ruff format 全绿、ruff check 仅剩既有告警;
前端 tsc -b / eslint / vite build 通过;接口端到端冒烟 29 项全绿(TestClient,探针用假客户端);
探针真机冒烟 3 例(有效 CK=True、别人 uid=False、裸 cookie=False)。
This commit is contained in:
yml2213
2026-10-16 19:38:59 +08:00
parent 99e8643d83
commit df8c63b829
32 changed files with 7449 additions and 16 deletions
+3
View File
@@ -161,6 +161,9 @@ _SENSITIVE_COLUMNS: tuple[tuple[str, str], ...] = (
("huya_register_success_logs", "password"),
("yyb_recharge_tasks", "login_qr_data"),
("yyb_recharge_tasks", "payment_qr_data"),
# 虎牙外部 CK 协作台账:CK 独立于 huya_accounts,同样必须加密落库。
("huya_external_orders", "cookie"),
("huya_external_orders", "raw_cookie"),
("proxy_config", "api_url"),
("proxy_config", "http"),
("proxy_config", "https"),
+2
View File
@@ -24,6 +24,7 @@ from .routers import (
cookies,
dashboard,
douyu,
files,
huya,
login,
proxy,
@@ -155,6 +156,7 @@ app.include_router(douyu.router)
app.include_router(yyb.router)
app.include_router(audit.router)
app.include_router(automation.router)
app.include_router(files.router)
@app.get("/api/health")
@@ -0,0 +1,92 @@
"""上传文件台账表 `file_assets`(在线协作的图片落库)。
协作里用户上传的图片本体放对象存储(ECS 与桶同地域时走内网 endpoint,
``oss-<region>-internal.aliyuncs.com``),库里只留 key 与元数据:
- 图片一律经 ``/api/files/object?key=...`` 由后端代理回读,**不下发 OSS 直链**。
参考 order_site 踩过的坑:曾经发过「15 分钟有效的签名链接」,结果入库时把当时的
链接原样存了下来,之后任何不重签的地方过一会儿必然裂图;
- ``object_key`` 里带 12 字节随机段(``scene/yyyy/mm/dd/<24位hex><ext>``),
不可枚举,所以普通链接就够用;
- ``thumbnail_object_key`` / ``medium_object_key`` 为空表示缩略图生成失败,
回读接口按 `.thumb.webp → .thumb.jpg → .thumb.png → 原图` 逐个候选回退。
"""
from __future__ import annotations
from collections.abc import Sequence
import sqlalchemy as sa
from alembic import op
revision: str = "20261016_0054"
down_revision: str | None = "20261015_0053"
branch_labels: str | Sequence[str] | None = None
depends_on: str | Sequence[str] | None = None
def _tables(bind) -> set[str]:
return set(sa.inspect(bind).get_table_names())
def upgrade() -> None:
bind = op.get_bind()
if "file_assets" in _tables(bind):
return
op.create_table(
"file_assets",
sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
# 对象存储里的 key:scene/yyyy/mm/dd/<24位随机hex><ext>
sa.Column("object_key", sa.String(length=512), nullable=False),
# 业务场景前缀(collab/… 等),同时决定公开还是私有
sa.Column("scene", sa.String(length=32), nullable=False, server_default="misc"),
sa.Column(
"original_filename",
sa.String(length=255),
nullable=False,
server_default="",
),
sa.Column(
"content_type", sa.String(length=64), nullable=False, server_default=""
),
sa.Column("size_bytes", sa.BigInteger(), nullable=False, server_default="0"),
sa.Column(
"thumbnail_object_key",
sa.String(length=512),
nullable=False,
server_default="",
),
sa.Column(
"medium_object_key",
sa.String(length=512),
nullable=False,
server_default="",
),
sa.Column(
"uploader_type", sa.String(length=32), nullable=False, server_default="user"
),
sa.Column(
"uploader_id", sa.String(length=64), nullable=False, server_default=""
),
sa.Column(
"status", sa.String(length=16), nullable=False, server_default="active"
),
sa.Column("metadata_json", sa.JSON(), nullable=True),
sa.Column("created_at", sa.DateTime(), nullable=False),
sa.Column("updated_at", sa.DateTime(), nullable=False),
)
# 回读接口按 key 精确定位,重复上传同一个 key 也要挡在唯一约束上。
op.create_index(
"ix_file_assets_object_key", "file_assets", ["object_key"], unique=True
)
op.create_index("ix_file_assets_scene", "file_assets", ["scene"])
op.create_index("ix_file_assets_uploader_id", "file_assets", ["uploader_id"])
def downgrade() -> None:
bind = op.get_bind()
if "file_assets" not in _tables(bind):
return
# MySQL 删表会连同索引一起删,不必逐个 drop_index。
op.drop_table("file_assets")
@@ -0,0 +1,147 @@
"""虎牙外部 CK 协作台账表 `huya_external_orders`(替代 Excel 多人协同表)。
**一行 = 一单 = 一个外部 CK**,设计见 ``docs/设计-虎牙外部CK协作台账.md``。
三个不能改错的地方:
1. **CK 独立存本表**(`cookie` / `raw_cookie`),刻意不写 `huya_accounts`、不做外键。
同一个虎牙号可能同时存在于两处、各自过期,那是设计上接受的代价(§2.3),
不是 bug;需要拿去跑任务时人工到工作台重新导入。
2. **`uid` 唯一但可空**:MySQL 的唯一索引允许多个 NULL,于是「先建单、后贴 CK」
与「一个虎牙号只能挂一单」能同时成立。别把它改成 NOT NULL —— 会让
「先建单」这条路直接写不进去。
3. **两套状态各管一摊**:`status`(业务进度)与 `ck_status`(凭据有效性)。
CK 失效不自动改业务状态,所以这两个列不要合并。
`cookie` / `raw_cookie` 同时登记进 `crypto_storage._SENSITIVE_COLUMNS`,
启动时的历史明文回填与落盘加密都靠那份清单。
"""
from __future__ import annotations
from collections.abc import Sequence
import sqlalchemy as sa
from alembic import op
revision: str = "20261016_0055"
down_revision: str | None = "20261016_0054"
branch_labels: str | Sequence[str] | None = None
depends_on: str | Sequence[str] | None = None
def _tables(bind) -> set[str]:
return set(sa.inspect(bind).get_table_names())
def upgrade() -> None:
bind = op.get_bind()
if "huya_external_orders" in _tables(bind):
return
op.create_table(
"huya_external_orders",
sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
# Excel B 列:订单编号,台账内唯一。
sa.Column("order_no", sa.String(length=64), nullable=False),
# Excel A 列:店铺。
sa.Column("shop", sa.String(length=64), nullable=False, server_default=""),
# Excel C 列:负责人。
sa.Column("owner_id", sa.Integer(), nullable=True),
# 外部 CK:uid 唯一可空(空 = 还没贴 CK)。
sa.Column("uid", sa.String(length=32), nullable=True),
sa.Column("yyuid", sa.String(length=32), nullable=False, server_default=""),
sa.Column(
"hy_username", sa.String(length=128), nullable=False, server_default=""
),
sa.Column("nickname", sa.String(length=128), nullable=False, server_default=""),
# 加密列(EncryptedText 在应用层加解密,DDL 是普通文本列)。
sa.Column("cookie", sa.Text(), nullable=False),
sa.Column("raw_cookie", sa.Text(), nullable=False),
sa.Column(
"ck_status",
sa.String(length=16),
nullable=False,
server_default="unverified",
),
sa.Column("ck_checked_at", sa.DateTime(), nullable=True),
sa.Column(
"ck_check_message", sa.String(length=256), nullable=False, server_default=""
),
# Excel D 列:绑定斗鱼号。
sa.Column(
"bind_douyu_account",
sa.String(length=128),
nullable=False,
server_default="",
),
sa.Column(
"bind_douyu_uid", sa.String(length=32), nullable=False, server_default=""
),
# Excel E/F 列:截图(OSS object_key 数组;MySQL JSON 列不能带 DEFAULT)。
sa.Column("bind_images", sa.JSON(), nullable=True),
sa.Column("home_images", sa.JSON(), nullable=True),
# Excel G 列(表头写「备注」,实为礼包名)+ 自由备注。
sa.Column(
"gift_name", sa.String(length=128), nullable=False, server_default=""
),
sa.Column("remark", sa.String(length=512), nullable=False, server_default=""),
# 业务进度 + 各节点时间戳(时间戳是「做过」的证据,状态是「卡在哪」)。
sa.Column(
"status", sa.String(length=16), nullable=False, server_default="pending"
),
sa.Column("bound_at", sa.DateTime(), nullable=True),
sa.Column("recharged_at", sa.DateTime(), nullable=True),
sa.Column("scripted_at", sa.DateTime(), nullable=True),
sa.Column("done_at", sa.DateTime(), nullable=True),
sa.Column(
"void_reason", sa.String(length=256), nullable=False, server_default=""
),
# 只读查询快照(不写 huya_accounts)。
sa.Column("points", sa.Integer(), nullable=True),
sa.Column("elite_opened", sa.Boolean(), nullable=True),
sa.Column("snapshot_at", sa.DateTime(), nullable=True),
sa.Column("created_by", sa.Integer(), nullable=True),
sa.Column("updated_by", sa.Integer(), nullable=True),
# 乐观锁版本号(每次写入 +1)。不用 updated_at 当锁:DATETIME 只到秒,
# 同一秒内的两次改动会撞成同一个值,锁会失效。
sa.Column("version", sa.Integer(), nullable=False, server_default="0"),
sa.Column("created_at", sa.DateTime(), nullable=False),
sa.Column("updated_at", sa.DateTime(), nullable=False),
)
# 订单号 / uid 唯一(uid 可空 → 多个 NULL 不冲突)。
op.create_index(
"ix_huya_external_orders_order_no",
"huya_external_orders",
["order_no"],
unique=True,
)
op.create_index(
"ix_huya_external_orders_uid", "huya_external_orders", ["uid"], unique=True
)
# 列表筛选维度。
op.create_index("ix_huya_external_orders_shop", "huya_external_orders", ["shop"])
op.create_index(
"ix_huya_external_orders_owner_id", "huya_external_orders", ["owner_id"]
)
op.create_index(
"ix_huya_external_orders_status", "huya_external_orders", ["status"]
)
op.create_index(
"ix_huya_external_orders_ck_status", "huya_external_orders", ["ck_status"]
)
op.create_index(
"ix_huya_external_orders_created_by", "huya_external_orders", ["created_by"]
)
# updated_at 兼作乐观锁版本号,也是默认排序键。
op.create_index(
"ix_huya_external_orders_updated_at", "huya_external_orders", ["updated_at"]
)
def downgrade() -> None:
bind = op.get_bind()
if "huya_external_orders" not in _tables(bind):
return
# MySQL 删表会连同索引一起删,不必逐个 drop_index。
op.drop_table("huya_external_orders")
@@ -0,0 +1,70 @@
"""`huya_external_orders` 增加「探针读到的绑定对象」快照列。
背景(2026-10-16 真机确认):CK 探针 `check_user_bind_game_account` 返回的是**绑定在该
虎牙号上的游戏账号**(账号昵称 / 角色名 / 平台·区服)。"这单到底绑了哪个号、哪个角色"
只有这里可信 —— 原来的 `bind_douyu_account` 是人工填的自由文本(Excel D 列)。
四个新列都由**探针独占**:每次验证覆盖写入,`bind_snapshot_at` 记读取时间;
人工不直接编辑(所以不在 EDITABLE_FIELDS 里)。
老列 `bind_douyu_account` / `bind_douyu_uid` **保留不动**:Excel 粘贴导入还按它映射,
已填的历史数据也不能丢。
可重复执行:按列判断,缺哪列补哪列。
"""
from __future__ import annotations
from collections.abc import Sequence
import sqlalchemy as sa
from alembic import op
revision: str = "20261016_0056"
down_revision: str | None = "20261016_0055"
branch_labels: str | Sequence[str] | None = None
depends_on: str | Sequence[str] | None = None
TABLE = "huya_external_orders"
# (列名, DDL 类型) —— 顺序即 DDL 顺序,方便人工核对。
_NEW_COLUMNS: tuple[tuple[str, sa.types.TypeEngine], ...] = (
("bind_game_account", sa.String(length=128)),
("bind_game_role", sa.String(length=128)),
("bind_game_channel", sa.String(length=128)),
("bind_snapshot_at", sa.DateTime()),
)
def _has_table(bind) -> bool:
return TABLE in set(sa.inspect(bind).get_table_names())
def _columns(bind) -> set[str]:
return {column["name"] for column in sa.inspect(bind).get_columns(TABLE)}
def upgrade() -> None:
bind = op.get_bind()
if not _has_table(bind):
return
existing = _columns(bind)
for name, column_type in _NEW_COLUMNS:
if name in existing:
continue
if name == "bind_snapshot_at":
op.add_column(TABLE, sa.Column(name, column_type, nullable=True))
else:
# 文本快照列必须有 server_default:NOT NULL 且无默认值会让已有行写不进去。
op.add_column(
TABLE, sa.Column(name, column_type, nullable=False, server_default="")
)
def downgrade() -> None:
bind = op.get_bind()
if not _has_table(bind):
return
existing = _columns(bind)
for name, _column_type in reversed(_NEW_COLUMNS):
if name in existing:
op.drop_column(TABLE, name)
+168
View File
@@ -985,3 +985,171 @@ class ExternalOrderCache(Base):
fetched_at: Mapped[datetime] = mapped_column(
UTCDateTime, default=_utcnow, index=True
)
class FileAsset(Base):
"""上传文件台账(对齐 order_site 的 ``file_assets``)。
对象本体在对象存储里(内网 OSS),库中只留 key 与元数据 —— 图片一律经
``/api/files/object?key=...`` 由后端代理回读,不下发 OSS 直链、也不存签名 URL
(签名链接会在入库时被原样存下来,过期后到处裂图)。
变体 key 为空表示缩略图生成失败,回读接口会自动回退原图。
"""
__tablename__ = "file_assets"
id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
object_key: Mapped[str] = mapped_column(
String(512), unique=True, nullable=False, index=True
)
scene: Mapped[str] = mapped_column(
String(32), default="misc", server_default="misc", index=True
)
original_filename: Mapped[str] = mapped_column(
String(255), default="", server_default=""
)
content_type: Mapped[str] = mapped_column(String(64), default="", server_default="")
size_bytes: Mapped[int] = mapped_column(BigInteger, default=0, server_default="0")
thumbnail_object_key: Mapped[str] = mapped_column(
String(512), default="", server_default=""
)
medium_object_key: Mapped[str] = mapped_column(
String(512), default="", server_default=""
)
uploader_type: Mapped[str] = mapped_column(
String(32), default="user", server_default="user"
)
uploader_id: Mapped[str] = mapped_column(
String(64), default="", server_default="", index=True
)
status: Mapped[str] = mapped_column(
String(16), default="active", server_default="active"
)
metadata_json: Mapped[dict | None] = mapped_column(JSON, nullable=True)
created_at: Mapped[datetime] = mapped_column(UTCDateTime, default=_utcnow)
updated_at: Mapped[datetime] = mapped_column(
UTCDateTime, default=_utcnow, onupdate=_utcnow
)
class HuyaExternalOrder(Base):
"""虎牙外部 CK 协作台账(替代 Excel 多人协同表)。
**一行 = 一单 = 一个外部 CK**,设计见 ``docs/设计-虎牙外部CK协作台账.md``。
两条边界(改动前先读设计文档 §2.3,别当成 bug 修):
1. **CK 独立存本表,刻意不写 ``huya_accounts``、不做外键**。同一个虎牙号可能同时
存在于两处、各自过期,这是已知代价;本表的 CK 只在「协作单」语境里有效,
需要拿去跑任务时人工到工作台重新导入,不自动同步。
2. **不接任务执行器**:绑定/充值/上脚本都在别的工具里做,本表只记录结果。
「一键送进工作台」是以后显式加的新动作。
两套状态各管一摊,不要混:``status`` 是业务进度(一单卡在哪一步),
``ck_status`` 是凭据本身有没有失效。CK 失效**不会**自动改业务状态。
"""
__tablename__ = "huya_external_orders"
id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
# Excel B 列:订单编号,台账内唯一(重复导入按「更新」处理)。
order_no: Mapped[str] = mapped_column(
String(64), unique=True, nullable=False, index=True
)
# Excel A 列:店铺。
shop: Mapped[str] = mapped_column(
String(64), default="", server_default="", index=True
)
# Excel C 列:负责人(共享表里只是筛选维度,不是权限边界)。
owner_id: Mapped[int | None] = mapped_column(
ForeignKey("users.id"), nullable=True, index=True
)
# ---- 外部 CK 本体(独立于 huya_accounts)----
# uid 唯一但可空:MySQL 唯一索引允许多个 NULL,于是「先建单、后贴 CK」与
# 「一个虎牙号只能挂一单」同时成立。
uid: Mapped[str | None] = mapped_column(
String(32), unique=True, nullable=True, index=True
)
yyuid: Mapped[str] = mapped_column(String(32), default="", server_default="")
hy_username: Mapped[str] = mapped_column(String(128), default="", server_default="")
nickname: Mapped[str] = mapped_column(String(128), default="", server_default="")
cookie: Mapped[str] = mapped_column(EncryptedText(), nullable=False, default="")
# App 原始凭据:网页运行 CK 被风控标记时可由它重建(见 rebuild_web_cookie_from_raw)。
raw_cookie: Mapped[str] = mapped_column(EncryptedText(), nullable=False, default="")
ck_status: Mapped[str] = mapped_column(
String(16), default="unverified", server_default="unverified", index=True
)
ck_checked_at: Mapped[datetime | None] = mapped_column(UTCDateTime, nullable=True)
ck_check_message: Mapped[str] = mapped_column(
String(256), default="", server_default=""
)
# ---- Excel D 列:绑定斗鱼号 ----
bind_douyu_account: Mapped[str] = mapped_column(
String(128), default="", server_default=""
)
bind_douyu_uid: Mapped[str] = mapped_column(
String(32), default="", server_default=""
)
# ---- 探针读到的绑定对象(游戏账号 / 角色,**只读快照**)----
# 2026-10-16 真机确认:`check_user_bind_game_account` 返回的是**绑定在该虎牙号上的
# 游戏账号**(账号昵称 / 角色名 / 平台·区服)。「这单绑了哪个号、哪个角色」只有这里
# 可信 —— 上面那个 `bind_douyu_account` 是人工填的自由文本,Excel 粘贴导入还在用它。
# 四个列**由探针独占**:每次验证覆盖写入,读的时间看 `bind_snapshot_at`;人工不编辑。
bind_game_account: Mapped[str] = mapped_column(
String(128), default="", server_default=""
)
bind_game_role: Mapped[str] = mapped_column(
String(128), default="", server_default=""
)
bind_game_channel: Mapped[str] = mapped_column(
String(128), default="", server_default=""
)
bind_snapshot_at: Mapped[datetime | None] = mapped_column(
UTCDateTime, nullable=True
)
# ---- Excel E/F 列:两张截图(存 OSS object_key,不存 URL —— URL 可推导,
# 存 URL 会在换存储时全部失效)。数组,第一张作封面。
bind_images: Mapped[list | None] = mapped_column(JSON, nullable=True)
home_images: Mapped[list | None] = mapped_column(JSON, nullable=True)
# ---- Excel G 列(表头写的「备注」,实际是礼包名)+ 自由备注 ----
gift_name: Mapped[str] = mapped_column(String(128), default="", server_default="")
remark: Mapped[str] = mapped_column(String(512), default="", server_default="")
# ---- 业务进度 ----
status: Mapped[str] = mapped_column(
String(16), default="pending", server_default="pending", index=True
)
bound_at: Mapped[datetime | None] = mapped_column(UTCDateTime, nullable=True)
recharged_at: Mapped[datetime | None] = mapped_column(UTCDateTime, nullable=True)
scripted_at: Mapped[datetime | None] = mapped_column(UTCDateTime, nullable=True)
done_at: Mapped[datetime | None] = mapped_column(UTCDateTime, nullable=True)
void_reason: Mapped[str] = mapped_column(String(256), default="", server_default="")
# ---- 只读查询快照(不写 huya_accounts)----
points: Mapped[int | None] = mapped_column(Integer, nullable=True)
elite_opened: Mapped[bool | None] = mapped_column(Boolean, nullable=True)
snapshot_at: Mapped[datetime | None] = mapped_column(UTCDateTime, nullable=True)
created_by: Mapped[int | None] = mapped_column(
ForeignKey("users.id"), nullable=True, index=True
)
# 最后修改人:协作表上要能一眼看出「这行刚被谁动过」。
updated_by: Mapped[int | None] = mapped_column(
ForeignKey("users.id"), nullable=True
)
# 乐观锁版本号:每次写入 +1。
# **刻意不用 updated_at 当锁**:本项目的 UTCDateTime 落库是 MySQL DATETIME
# (秒级精度),同一秒内的两次改动会得到完全相同的 updated_at,
# 锁就形同虚设 —— Excel 那种「后保存的覆盖前一个」会原样复活。
version: Mapped[int] = mapped_column(Integer, default=0, server_default="0")
created_at: Mapped[datetime] = mapped_column(UTCDateTime, default=_utcnow)
# 显示用(列表默认排序键);并发保护靠上面的 version。
updated_at: Mapped[datetime] = mapped_column(
UTCDateTime, default=_utcnow, onupdate=_utcnow, index=True
)
+18
View File
@@ -49,6 +49,10 @@ PERMISSIONS = {
"huya:bind": "虎牙绑定操作",
"huya:recharge": "虎牙充值操作",
"huya:config": "虎牙配置管理",
# 外部 CK 协作台账(共享表,替代 Excel;见 docs/设计-虎牙外部CK协作台账.md)
"huya:collab:view": "查看外部 CK 协作台账",
"huya:collab:edit": "编辑外部 CK 协作台账",
"huya:collab:manage": "删除外部 CK 协作台账",
# 代理 & 白名单
"proxy:manage": "代理配置管理",
"whitelist:manage": "白名单配置管理",
@@ -56,6 +60,9 @@ PERMISSIONS = {
# 自动化
"automation:view": "查看自动化作业与运行历史",
"automation:manage": "修改自动化配置、手动触发作业",
# 文件/附件(在线协作上传图片)
"file:view": "查看上传的文件",
"file:upload": "上传文件",
# 系统
"system:settings": "系统设置",
"audit:view": "查看审计日志",
@@ -94,10 +101,16 @@ ROLE_PERMISSIONS = {
"huya:bind",
"huya:recharge",
"huya:config",
# 协作台账是共享表:运营既能改也能删。
"huya:collab:view",
"huya:collab:edit",
"huya:collab:manage",
"proxy:manage",
"whitelist:manage",
"whitelist:test",
"automation:view",
"file:view",
"file:upload",
],
"support": [
"account:view_assigned",
@@ -109,6 +122,11 @@ ROLE_PERMISSIONS = {
"huya:view_assigned",
"huya:tag",
"huya:task",
# 客服能看能改(共享表,靠审计留痕),但删除只给运营。
"huya:collab:view",
"huya:collab:edit",
"file:view",
"file:upload",
],
}
+165
View File
@@ -0,0 +1,165 @@
"""文件上传与回读(在线协作里的图片)。
- ``POST /api/files/upload`` multipart 上传,需要登录 + ``file:upload`` 权限;
- ``GET /api/files/object`` 由后端代理对象存储回读,需要登录 + ``file:view`` 权限。
两个接口都在 ``def``(同步)里实现:FastAPI 会把它们丢到线程池,图片解码与对象
存储 IO 不会占住事件循环。
图片只用本服务的代理地址回读(``/api/files/object?key=...``),**不下发 OSS 直链**。
前端 ``<img src>`` 是同源请求,浏览器会自动带上登录 cookie,权限照样生效。
"""
from __future__ import annotations
import contextlib
from collections.abc import Iterator
from typing import Any
from fastapi import (
APIRouter,
Depends,
File,
Form,
HTTPException,
Query,
Request,
UploadFile,
)
from fastapi.responses import Response, StreamingResponse
from sqlalchemy.orm import Session
from ..database import get_db
from ..deps import require_permission
from ..models import User
from ..schemas import FileAssetOut
from ..services.audit_service import record_audit
from ..services.file_service import (
FileUploadError,
get_stored_object,
upload_file_asset,
)
from ..services.file_storage import StorageUnavailableError, max_upload_size_bytes
router = APIRouter(prefix="/api/files", tags=["files"])
_READ_CHUNK_SIZE = 64 * 1024
# 私有文件缓存在浏览器侧只留 5 分钟:协作场景里图片可能被替换或下线。
_PRIVATE_CACHE_CONTROL = "private, max-age=300"
@router.post("/upload", response_model=FileAssetOut)
def upload_file(
file: UploadFile = File(...),
scene: str = Form("misc"),
db: Session = Depends(get_db),
current: User = Depends(require_permission("file:upload")),
) -> FileAssetOut:
"""上传一张图片(也接受 PDF)。
先按上限多读 1 字节再判断,超限的请求不会把整个文件灌进内存。
"""
limit = max_upload_size_bytes()
data = file.file.read(limit + 1)
if len(data) > limit:
raise HTTPException(
status_code=413, detail=f"文件不能超过 {limit // (1024 * 1024)}MB"
)
filename = (file.filename or "").strip()
try:
result = upload_file_asset(
db,
data=data,
filename=filename,
content_type=file.content_type or "",
scene=scene,
uploader_type="user",
uploader_id=str(current.id),
)
except FileUploadError as exc:
raise HTTPException(status_code=exc.status_code, detail=exc.detail) from exc
except StorageUnavailableError as exc:
raise HTTPException(status_code=503, detail="文件存储暂时不可用") from exc
record_audit(
db,
current,
action="file:upload",
target=result.object_key,
detail={
"scene": scene,
"filename": filename,
"content_type": result.content_type,
"size": result.size,
},
)
db.commit()
return FileAssetOut(
object_key=result.object_key,
url=result.url,
thumbnail_url=result.thumbnail_url,
medium_url=result.medium_url,
filename=result.filename,
content_type=result.content_type,
size=result.size,
)
@router.get("/object")
def read_file_object(
request: Request,
key: str = Query(..., min_length=1, max_length=512, description="对象 key"),
variant: str = Query("", description="thumb / medium;留空取原图"),
_current: User = Depends(require_permission("file:view")),
) -> Response:
"""回读对象(变体缺失时自动回退原图),支持 ETag 304。"""
try:
stored = get_stored_object(key, variant)
except FileUploadError as exc:
raise HTTPException(status_code=exc.status_code, detail=exc.detail) from exc
except StorageUnavailableError as exc:
raise HTTPException(status_code=503, detail="文件存储暂时不可用") from exc
if stored.etag and request.headers.get("if-none-match") == stored.etag:
_close_quietly(stored.reader)
return Response(status_code=304, headers={"ETag": stored.etag})
headers: dict[str, str] = {
"Cache-Control": _PRIVATE_CACHE_CONTROL,
"X-Content-Type-Options": "nosniff",
# 图片/PDF 本身已压缩,GZip 中间件再压一遍只是白烧 CPU,
# 这里显式声明未编码,让中间件跳过(starlette 见到 Content-Encoding 就不压)。
"Content-Encoding": "identity",
}
if stored.etag:
headers["ETag"] = stored.etag
if stored.size > 0:
headers["Content-Length"] = str(stored.size)
return StreamingResponse(
_iter_reader(stored.reader),
media_type=stored.content_type or "application/octet-stream",
headers=headers,
)
def _iter_reader(reader: Any) -> Iterator[bytes]:
"""把存储侧的可读对象按固定块大小吐给客户端,结束时确保关闭。"""
try:
while True:
chunk = reader.read(_READ_CHUNK_SIZE)
if not chunk:
break
yield chunk
finally:
_close_quietly(reader)
def _close_quietly(reader: Any) -> None:
close = getattr(reader, "close", None)
if callable(close):
# 关闭失败不影响已经发出的响应(本地 BytesIO / S3 StreamingBody 都可能抛)。
with contextlib.suppress(Exception):
close()
+3
View File
@@ -19,6 +19,7 @@ from .accounts import (
set_account_tag,
)
from .accounts import router as accounts_router
from .collab import router as collab_router
from .cookies import router as cookies_router
from .devices import router as devices_router
from .login import (
@@ -63,6 +64,8 @@ router.include_router(cookies_router)
router.include_router(workbench_router)
router.include_router(devices_router)
router.include_router(pay_router)
# 外部 CK 协作台账(共享表,替代 Excel)
router.include_router(collab_router)
__all__ = [
"app_password_login_account",
+371
View File
@@ -0,0 +1,371 @@
"""虎牙外部 CK 协作台账接口。
设计见 ``docs/设计-虎牙外部CK协作台账.md``。这一层只做三件事:
参数校验、权限、异常翻译;业务规则全在 ``services/huya_collab_service.py``。
权限:
- 查看 = ``huya:collab:view``(运营 + 客服)
- 编辑 = ``huya:collab:edit``(运营 + 客服;共享表,改动靠审计留痕)
- 删除 = ``huya:collab:manage``(**只给运营**)
图片上传不在这里:前端直接调 ``POST /api/files/upload``,把返回的 object_key
提交给本模块的 images 接口。
CK 验证是**只读探针**(``POST .../verify`` 单条、``POST .../ck/verify`` 批量):
人工触发、串行带间隔,不建 ``HuyaAccount``、不改业务状态(设计文档 §5.2)。
"""
from __future__ import annotations
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.orm import Session
from ...database import get_db
from ...deps import require_permission
from ...models import AuditLog, HuyaExternalOrder, User
from ...schemas import (
HuyaExternalOrderAuditOut,
HuyaExternalOrderCkRequest,
HuyaExternalOrderCkStatusRequest,
HuyaExternalOrderCreate,
HuyaExternalOrderImagesRequest,
HuyaExternalOrderImportRequest,
HuyaExternalOrderListOut,
HuyaExternalOrderOut,
HuyaExternalOrderOwnerOut,
HuyaExternalOrderStatusRequest,
HuyaExternalOrderSummaryOut,
HuyaExternalOrderUpdate,
HuyaExternalOrderVerifyOut,
HuyaExternalOrderVerifyRequest,
)
from ...services import huya_collab_service as collab
router = APIRouter()
_AUDIT_TARGET_PREFIX = "huya_external_order:"
_AUDIT_TIMELINE_LIMIT = 100
def _http_error(exc: collab.CollabError) -> HTTPException:
return HTTPException(status_code=exc.status_code, detail=exc.detail)
def _serialize_one(db: Session, order: HuyaExternalOrder) -> dict:
return collab.serialize_order(order, users=collab.users_by_id(db, [order]))
# --------------------------------------------------------------------------
# 字面量路径必须声明在 /{order_id} 之前,否则 "summary" 会被当成 id
# --------------------------------------------------------------------------
@router.get("/external-orders/summary", response_model=HuyaExternalOrderSummaryOut)
def external_orders_summary(
db: Session = Depends(get_db),
_current: User = Depends(require_permission("huya:collab:view")),
):
"""页头统计条:各业务状态计数 + CK 失效数。"""
return collab.summary(db)
@router.get("/external-orders/owners", response_model=list[HuyaExternalOrderOwnerOut])
def external_orders_owners(
db: Session = Depends(get_db),
_current: User = Depends(require_permission("huya:collab:view")),
):
"""负责人候选:全部活跃用户(不是权限边界,只是筛选/指派用)。"""
rows = (
db.query(User.id, User.username)
.filter(User.is_active.is_(True))
.order_by(User.username)
.all()
)
return [{"id": int(row[0]), "username": str(row[1])} for row in rows]
@router.get("/external-orders/shops", response_model=list[str])
def external_orders_shops(
db: Session = Depends(get_db),
_current: User = Depends(require_permission("huya:collab:view")),
):
"""已用过的店铺列表(筛选下拉)。"""
return collab.list_shops(db)
@router.get("/external-orders", response_model=HuyaExternalOrderListOut)
def list_external_orders(
shop: str = Query("", max_length=64),
owner_id: int | None = Query(None),
status: str = Query("", max_length=16),
ck_status: str = Query("", max_length=16),
keyword: str = Query("", max_length=128),
include_void: bool = Query(False, description="是否包含已作废的行(默认隐藏)"),
page: int = Query(1, ge=1),
page_size: int = Query(50, ge=1, le=200),
db: Session = Depends(get_db),
_current: User = Depends(require_permission("huya:collab:view")),
):
"""共享视图:默认不按人过滤(负责人只是筛选维度,不是权限边界)。"""
rows, total = collab.list_orders(
db,
shop=shop,
owner_id=owner_id,
status=status,
ck_status=ck_status,
keyword=keyword,
include_void=include_void,
page=page,
page_size=page_size,
)
names = collab.users_by_id(db, rows)
return {
"items": [collab.serialize_order(row, users=names) for row in rows],
"total": total,
"page": page,
"page_size": page_size,
}
@router.post("/external-orders", response_model=HuyaExternalOrderOut)
def create_external_order(
req: HuyaExternalOrderCreate,
db: Session = Depends(get_db),
current: User = Depends(require_permission("huya:collab:edit")),
):
"""新建一行(可同时贴一份外部 CK)。订单号唯一,重复会 409。"""
try:
order = collab.create_order(
db,
current,
order_no=req.order_no,
shop=req.shop,
owner_id=req.owner_id,
ck_text=req.ck_text,
bind_douyu_account=req.bind_douyu_account,
gift_name=req.gift_name,
remark=req.remark,
)
except collab.CollabError as exc:
raise _http_error(exc) from exc
return _serialize_one(db, order)
@router.post("/external-orders/import")
def import_external_orders(
req: HuyaExternalOrderImportRequest,
db: Session = Depends(get_db),
current: User = Depends(require_permission("huya:collab:edit")),
):
"""Excel 粘贴批量导入。单行失败只记在 ``errors`` 里,不影响其他行。"""
owners = {
str(name): int(user_id)
for user_id, name in db.query(User.id, User.username)
.filter(User.is_active.is_(True))
.all()
}
return collab.import_orders(db, current, req.text, owner_by_name=owners)
@router.post("/external-orders/ck/verify", response_model=HuyaExternalOrderVerifyOut)
def verify_external_orders_ck(
req: HuyaExternalOrderVerifyRequest,
db: Session = Depends(get_db),
current: User = Depends(require_permission("huya:collab:edit")),
):
"""批量验证 CK(只读探针):人工触发、串行、带间隔,不做定时轮询。
单条失败只记在 ``results`` 里,不影响其他条(AGENTS §2)。探针只读,
**不会**建 ``HuyaAccount``、也不会改业务状态。
"""
try:
orders = collab.list_orders_by_ids(db, req.ids)
return collab.verify_ck_batch(db, current, orders)
except collab.CollabError as exc:
raise _http_error(exc) from exc
# --------------------------------------------------------------------------
# 单行操作
# --------------------------------------------------------------------------
@router.get("/external-orders/{order_id}", response_model=HuyaExternalOrderOut)
def get_external_order(
order_id: int,
db: Session = Depends(get_db),
_current: User = Depends(require_permission("huya:collab:view")),
):
try:
order = collab.get_order(db, order_id)
except collab.CollabError as exc:
raise _http_error(exc) from exc
return _serialize_one(db, order)
@router.get(
"/external-orders/{order_id}/timeline",
response_model=list[HuyaExternalOrderAuditOut],
)
def external_order_timeline(
order_id: int,
db: Session = Depends(get_db),
_current: User = Depends(require_permission("huya:collab:view")),
):
"""操作时间线:直接读 ``audit_logs``,不另建事件表。"""
rows = (
db.query(AuditLog)
.filter(AuditLog.target == f"{_AUDIT_TARGET_PREFIX}{order_id}")
.order_by(AuditLog.id.desc())
.limit(_AUDIT_TIMELINE_LIMIT)
.all()
)
return [
{
"id": row.id,
"action": row.action,
"username": row.username or "",
"detail": row.detail or "",
"success": row.success,
"created_at": row.created_at,
}
for row in rows
]
@router.put("/external-orders/{order_id}", response_model=HuyaExternalOrderOut)
def update_external_order(
order_id: int,
req: HuyaExternalOrderUpdate,
db: Session = Depends(get_db),
current: User = Depends(require_permission("huya:collab:edit")),
):
"""编辑(部分字段)。带 ``expected_version`` 做乐观锁,冲突返回 409。"""
try:
order = collab.get_order(db, order_id)
payload = req.model_dump(exclude_unset=True)
expected_version = payload.pop("expected_version", None)
collab.update_order(
db, current, order, payload, expected_version=expected_version
)
except collab.CollabError as exc:
raise _http_error(exc) from exc
return _serialize_one(db, order)
@router.post("/external-orders/{order_id}/status", response_model=HuyaExternalOrderOut)
def update_external_order_status(
order_id: int,
req: HuyaExternalOrderStatusRequest,
db: Session = Depends(get_db),
current: User = Depends(require_permission("huya:collab:edit")),
):
"""推进/回退业务状态。回退必须显式带 ``rollback=true``。"""
try:
order = collab.get_order(db, order_id)
collab.assert_version(order, req.expected_version)
collab.set_status(
db,
current,
order,
req.status,
reason=req.reason,
rollback=req.rollback,
)
except collab.CollabError as exc:
raise _http_error(exc) from exc
return _serialize_one(db, order)
@router.post("/external-orders/{order_id}/ck", response_model=HuyaExternalOrderOut)
def update_external_order_ck(
order_id: int,
req: HuyaExternalOrderCkRequest,
db: Session = Depends(get_db),
current: User = Depends(require_permission("huya:collab:edit")),
):
"""贴入/换 CK(``action=paste``)或从 raw_cookie 重建(``action=rebuild``)。"""
try:
order = collab.get_order(db, order_id)
collab.assert_version(order, req.expected_version)
if req.action == "rebuild":
collab.rebuild_ck(db, current, order)
else:
collab.set_ck(db, current, order, req.ck_text)
except collab.CollabError as exc:
raise _http_error(exc) from exc
return _serialize_one(db, order)
@router.post(
"/external-orders/{order_id}/ck/status", response_model=HuyaExternalOrderOut
)
def update_external_order_ck_status(
order_id: int,
req: HuyaExternalOrderCkStatusRequest,
db: Session = Depends(get_db),
current: User = Depends(require_permission("huya:collab:edit")),
):
"""人工停用 / 恢复这份 CK(``disabled`` / ``unverified``)。
``valid`` / ``invalid`` **只能**由只读探针给(``POST .../verify``):
人工标「有效」等于绕过验证(设计文档 §4.2)。
"""
try:
order = collab.get_order(db, order_id)
collab.assert_version(order, req.expected_version)
collab.set_manual_ck_status(db, current, order, req.status, message=req.message)
except collab.CollabError as exc:
raise _http_error(exc) from exc
return _serialize_one(db, order)
@router.post("/external-orders/{order_id}/verify", response_model=HuyaExternalOrderOut)
def verify_external_order_ck(
order_id: int,
db: Session = Depends(get_db),
current: User = Depends(require_permission("huya:collab:edit")),
):
"""验证 CK(只读探针):写 ``ck_status`` / ``ck_checked_at`` / ``ck_check_message``。
成功时顺手补 ``bind_douyu_account`` / ``bind_douyu_uid``(**只补空值**)。
CK 失效**不会**自动改业务状态,列表上只做显式提示。
"""
try:
order = collab.get_order(db, order_id)
collab.verify_ck(db, current, order)
except collab.CollabError as exc:
raise _http_error(exc) from exc
return _serialize_one(db, order)
@router.post("/external-orders/{order_id}/images", response_model=HuyaExternalOrderOut)
def update_external_order_images(
order_id: int,
req: HuyaExternalOrderImagesRequest,
db: Session = Depends(get_db),
current: User = Depends(require_permission("huya:collab:edit")),
):
"""整槽替换图片(提交 ``/api/files/upload`` 返回的 object_key 数组)。"""
try:
order = collab.get_order(db, order_id)
collab.assert_version(order, req.expected_version)
collab.set_images(db, current, order, req.slot, req.images)
except collab.CollabError as exc:
raise _http_error(exc) from exc
return _serialize_one(db, order)
@router.delete("/external-orders/{order_id}")
def delete_external_order(
order_id: int,
db: Session = Depends(get_db),
current: User = Depends(require_permission("huya:collab:manage")),
):
"""删除一行(**只给运营**)。只删行,不删 OSS 里的图(交给孤儿清理脚本)。"""
try:
order = collab.get_order(db, order_id)
snapshot = collab.delete_order(db, current, order)
except collab.CollabError as exc:
raise _http_error(exc) from exc
return {"success": True, "order_no": snapshot["order_no"]}
+207
View File
@@ -1064,3 +1064,210 @@ class AppInfo(BaseModel):
class MessageResponse(BaseModel):
message: str
success: bool = True
# ---- 文件上传(在线协作图片) ----
class FileAssetOut(BaseModel):
"""上传结果。url 一律是本服务的代理地址,不下发对象存储直链。"""
object_key: str
url: str
thumbnail_url: str
medium_url: str
filename: str
content_type: str
size: int
# ---- 虎牙外部 CK 协作台账(见 docs/设计-虎牙外部CK协作台账.md) ----
class HuyaExternalOrderCreate(BaseModel):
"""新建一行(可同时贴一份外部 CK)。"""
order_no: str = Field(..., min_length=1, max_length=64)
shop: str = Field("", max_length=64)
owner_id: int | None = None
ck_text: str = ""
bind_douyu_account: str = Field("", max_length=128)
gift_name: str = Field("", max_length=128)
remark: str = Field("", max_length=512)
class HuyaExternalOrderUpdate(BaseModel):
"""部分更新:只提交要改的字段(服务端用 ``exclude_unset`` 识别)。"""
order_no: str | None = Field(None, max_length=64)
shop: str | None = Field(None, max_length=64)
owner_id: int | None = None
bind_douyu_account: str | None = Field(None, max_length=128)
bind_douyu_uid: str | None = Field(None, max_length=32)
gift_name: str | None = Field(None, max_length=128)
remark: str | None = Field(None, max_length=512)
# 乐观锁:客户端拿到的版本号。不一致说明别人先改了 → 409。
expected_version: int | None = None
class HuyaExternalOrderStatusRequest(BaseModel):
"""推进/回退业务状态。"""
status: str = Field(..., min_length=1, max_length=16)
reason: str = Field("", max_length=256)
# 目标不是「向前一步」时必须显式置 True,避免误点把状态改回去。
rollback: bool = False
expected_version: int | None = None
class HuyaExternalOrderCkRequest(BaseModel):
"""贴入/换 CK,或从 raw_cookie 重建。"""
ck_text: str = ""
action: str = Field("paste", pattern="^(paste|rebuild)$")
expected_version: int | None = None
class HuyaExternalOrderCkStatusRequest(BaseModel):
"""人工改 CK 状态:**只能**改成「已停用」或「未验证」。
``valid`` / ``invalid`` 由只读探针给(``POST .../verify``)——人工标「有效」等于绕过验证。
"""
status: str = Field(..., pattern="^(unverified|disabled)$")
message: str = Field("", max_length=256)
expected_version: int | None = None
class HuyaExternalOrderImagesRequest(BaseModel):
"""整槽替换某个图片槽位(提交 /api/files/upload 返回的 object_key)。"""
slot: str = Field(..., pattern="^(bind_images|home_images)$")
images: list[str] = Field(default_factory=list)
expected_version: int | None = None
class HuyaExternalOrderImportRequest(BaseModel):
"""Excel 粘贴批量导入(TSV,首行可为表头)。"""
text: str
class HuyaExternalOrderVerifyRequest(BaseModel):
"""批量验证 CK(探针):人工勾选的行 id(一次最多 50 条)。"""
ids: list[int] = Field(default_factory=list)
class HuyaExternalOrderVerifyItemOut(BaseModel):
"""批量验证里的一行结论(``ok=False`` 时看 ``message``)。"""
id: int
order_no: str = ""
ok: bool = False
ck_status: str = ""
message: str = ""
binding: dict[str, str] = Field(default_factory=dict)
class HuyaExternalOrderVerifyOut(BaseModel):
"""批量验证汇总:``valid + failed = total``。"""
total: int
valid: int
failed: int
results: list[HuyaExternalOrderVerifyItemOut] = Field(default_factory=list)
class HuyaExternalOrderOut(BaseModel):
"""一行的完整视图。
``*_image_urls`` 由后端拼(``/api/files/object?key=...``),
``*_image_thumb_urls`` 走缩略图变体(变体缺失自动回退原图)。
"""
id: int
order_no: str
shop: str
owner_id: int | None = None
owner_name: str = ""
uid: str = ""
yyuid: str = ""
hy_username: str = ""
nickname: str = ""
has_cookie: bool = False
has_raw_cookie: bool = False
ck_status: str = "unverified"
ck_status_label: str = ""
ck_checked_at: datetime | None = None
ck_check_message: str = ""
bind_douyu_account: str = ""
bind_douyu_uid: str = ""
# 探针读到的绑定对象(只读快照:账号 / 角色 / 平台·区服 + 读取时间)
bind_game_account: str = ""
bind_game_role: str = ""
bind_game_channel: str = ""
bind_snapshot_at: datetime | None = None
bind_images: list[str] = Field(default_factory=list)
home_images: list[str] = Field(default_factory=list)
bind_image_urls: list[str] = Field(default_factory=list)
home_image_urls: list[str] = Field(default_factory=list)
bind_image_thumb_urls: list[str] = Field(default_factory=list)
home_image_thumb_urls: list[str] = Field(default_factory=list)
gift_name: str = ""
remark: str = ""
status: str = "pending"
status_label: str = ""
next_status: str | None = None
bound_at: datetime | None = None
recharged_at: datetime | None = None
scripted_at: datetime | None = None
done_at: datetime | None = None
void_reason: str = ""
points: int | None = None
elite_opened: bool | None = None
snapshot_at: datetime | None = None
created_by: int | None = None
created_by_name: str = ""
updated_by: int | None = None
updated_by_name: str = ""
version: int = 0
created_at: datetime | None = None
updated_at: datetime | None = None
class HuyaExternalOrderListOut(BaseModel):
"""列表响应:共享视图,带上总数供分页使用。"""
items: list[HuyaExternalOrderOut]
total: int
page: int
page_size: int
class HuyaExternalOrderSummaryOut(BaseModel):
"""页头统计条。"""
total: int
by_status: dict[str, int]
ck_invalid: int
class HuyaExternalOrderOwnerOut(BaseModel):
"""负责人下拉项(活跃用户)。"""
id: int
username: str
class HuyaExternalOrderAuditOut(BaseModel):
"""详情页的时间线条目(直接来自 audit_logs)。"""
id: int
action: str
username: str = ""
detail: str = ""
success: bool | None = None
created_at: datetime | None = None
+378
View File
@@ -0,0 +1,378 @@
"""上传服务:校验 → 生成对象 key → 落对象存储 → 生成缩略图变体 → 落台账。
流程与两个参考实现对齐(order_site 的 ``file-storage-service.ts``、
hfb_sys 的 ``modules/file/service.go``):
1. 内存里收下整个文件(上限 10MB),先判大小再**按魔数嗅探真实类型**(不信
Content-Type);
2. ``objectKey = scene/yyyy/mm/dd/<24位随机hex><ext>`` —— 随机段保证对象不可枚举;
3. 原图入库后再生成长边 480/1280 的 ``thumb`` / ``medium`` 变体,**变体失败不阻断
上传**(回读接口会自动回退原图);
4. 任何一步失败都把已经写进对象存储的 key 全部删掉,避免留下孤儿对象;
5. 元数据落 ``file_assets`` 台账,便于溯源与后续清理。
"""
from __future__ import annotations
import io
import re
import secrets
from dataclasses import dataclass
from datetime import UTC, datetime
from typing import Any
from urllib.parse import quote
from loguru import logger
from PIL import Image, ImageOps, features
from sqlalchemy.orm import Session
from ..models import FileAsset
from .file_storage import (
ObjectStorage,
StorageSettings,
StoredObject,
get_object_storage,
max_upload_size_bytes,
normalize_object_key,
)
ALLOWED_CONTENT_TYPES = frozenset(
{"image/jpeg", "image/png", "image/webp", "application/pdf"}
)
IMAGE_CONTENT_TYPES = frozenset({"image/jpeg", "image/png", "image/webp"})
VARIANT_THUMB = "thumb"
VARIANT_MEDIUM = "medium"
_VARIANT_NAMES = (VARIANT_THUMB, VARIANT_MEDIUM)
_VARIANT_MAX_SIDE = {VARIANT_THUMB: 480, VARIANT_MEDIUM: 1280}
_VARIANT_QUALITY = {VARIANT_THUMB: 76, VARIANT_MEDIUM: 82}
_EXTENSION_BY_CONTENT_TYPE = {
"image/jpeg": ".jpg",
"image/png": ".png",
"image/webp": ".webp",
"application/pdf": ".pdf",
}
_SCENE_PATTERN = re.compile(r"[^a-z0-9_-]+")
_SAFE_EXT_PATTERN = re.compile(r"^\.[a-z0-9]{1,8}$")
_MAX_SCENE_LENGTH = 32
class FileUploadError(RuntimeError):
"""上传/读取的业务错误,路由层据此转成对应 HTTP 状态码。"""
def __init__(self, detail: str, *, status_code: int = 400, code: str = ""):
super().__init__(detail)
self.detail = detail
self.status_code = status_code
self.code = code
@dataclass(frozen=True)
class ImageVariant:
"""一张缩略图变体(内容保存在内存里,随原图一起写入对象存储)。"""
name: str
content: bytes
content_type: str
@dataclass(frozen=True)
class UploadedFile:
"""上传结果,同时作为接口响应体。"""
object_key: str
url: str
thumbnail_url: str
medium_url: str
filename: str
content_type: str
size: int
def normalize_scene(raw_scene: Any) -> str:
"""scene 归一化:只留小写字母/数字/下划线/连字符,缺省 misc。"""
scene = _SCENE_PATTERN.sub("-", str(raw_scene or "").strip().lower()).strip("-")
return (scene or "misc")[:_MAX_SCENE_LENGTH]
def sniff_content_type(data: bytes) -> str:
"""按文件头魔数判断类型;识别不出返回空串。"""
if data[:3] == b"\xff\xd8\xff":
return "image/jpeg"
if data[:8] == b"\x89PNG\r\n\x1a\n":
return "image/png"
if data[:4] == b"RIFF" and data[8:12] == b"WEBP":
return "image/webp"
if data[:4] == b"%PDF":
return "application/pdf"
return ""
def resolve_content_type(hint: Any, data: bytes) -> str:
"""先信魔数,再信调用方给的 Content-Type。"""
detected = sniff_content_type(data)
if detected:
return detected
normalized = str(hint or "").strip().lower().split(";")[0]
return normalized or "application/octet-stream"
def build_object_key(scene: str, content_type: str, filename: str = "") -> str:
"""``scene/yyyy/mm/dd/<24位随机hex><ext>``。"""
now = datetime.now(UTC)
token = secrets.token_hex(12)
return f"{scene}/{now.year:04d}/{now.month:02d}/{now.day:02d}/{token}{_pick_extension(content_type, filename)}"
def image_variant_key(object_key: str, variant: str, extension: str) -> str:
"""变体 key:在扩展名前插入 ``.<variant>``。"""
base = object_key
for known in _EXTENSION_BY_CONTENT_TYPE.values():
if object_key.lower().endswith(known):
base = object_key[: -len(known)]
break
return f"{base}.{variant}{extension}"
def image_variant_fallback_keys(object_key: str, variant: str) -> list[str]:
"""变体 key 的候选顺序:webp → jpg → png → 原图。
变体的扩展名取决于源图是否有透明通道(png/webp 保 alpha 出 webp,
其余出 jpg),而回读接口只知道基础 key,所以这里按候选逐个试。
"""
if variant not in _VARIANT_NAMES:
return [object_key]
candidates = [
image_variant_key(object_key, variant, ext) for ext in (".webp", ".jpg", ".png")
]
candidates.append(object_key)
return list(dict.fromkeys(candidates))
def build_file_url(object_key: str, variant: str = "") -> str:
"""文件访问地址(走后端代理,不暴露对象存储直链)。"""
url = f"/api/files/object?key={quote(normalize_object_key(object_key), safe='')}"
if variant:
url = f"{url}&variant={quote(variant, safe='')}"
return url
def _webp_available() -> bool:
return bool(features.check("webp"))
def _pick_extension(content_type: str, filename: str) -> str:
known = _EXTENSION_BY_CONTENT_TYPE.get(content_type)
if known:
return known
candidate = ""
if "." in filename:
candidate = filename[filename.rfind(".") :].lower()
return candidate if _SAFE_EXT_PATTERN.match(candidate) else ".bin"
def _load_image(data: bytes) -> Image.Image | None:
try:
image = Image.open(io.BytesIO(data))
image.load()
except Exception: # noqa: BLE001 坏图不该让整次上传失败
return None
try:
# 手机截图常带 EXIF 方向,先摆正再缩放(对齐 sharp 的 .rotate())。
return ImageOps.exif_transpose(image)
except Exception: # noqa: BLE001
return image
def _encode_variant(
image: Image.Image, *, preserve_alpha: bool, quality: int
) -> tuple[bytes, str]:
buffer = io.BytesIO()
if preserve_alpha:
prepared = image.convert("RGBA")
if _webp_available():
prepared.save(buffer, "WEBP", quality=quality, method=4)
return buffer.getvalue(), "image/webp"
prepared.save(buffer, "PNG", optimize=True)
return buffer.getvalue(), "image/png"
# JPEG 没有透明通道;源图也只会是无 alpha 的 JPEG,直接转 RGB 即可。
image.convert("RGB").save(buffer, "JPEG", quality=quality, optimize=True)
return buffer.getvalue(), "image/jpeg"
def generate_image_variants(data: bytes, content_type: str) -> list[ImageVariant]:
"""生成 thumb/medium 变体;不是图片或解码失败时返回空列表。"""
if content_type not in IMAGE_CONTENT_TYPES:
return []
source = _load_image(data)
if source is None:
logger.warning(f"图片解码失败,跳过变体生成 content_type={content_type}")
return []
# 与两个参考实现一致:png/webp 视为可能带透明通道,保留 alpha 输出 webp。
preserve_alpha = content_type in ("image/png", "image/webp")
variants: list[ImageVariant] = []
try:
for name in _VARIANT_NAMES:
max_side = _VARIANT_MAX_SIDE[name]
try:
frame = source.copy()
frame.thumbnail((max_side, max_side), Image.Resampling.LANCZOS)
content, variant_type = _encode_variant(
frame, preserve_alpha=preserve_alpha, quality=_VARIANT_QUALITY[name]
)
frame.close()
except Exception as exc: # noqa: BLE001 单张变体失败不影响其余变体
logger.warning(f"生成图片变体失败 variant={name}: {exc}")
continue
if content:
variants.append(
ImageVariant(name=name, content=content, content_type=variant_type)
)
finally:
source.close()
return variants
def upload_file_asset(
db: Session,
*,
data: bytes,
filename: str = "",
content_type: str = "",
scene: str = "misc",
uploader_type: str = "user",
uploader_id: str = "",
settings: StorageSettings | None = None,
) -> UploadedFile:
"""校验并写入一份上传文件。
``settings`` 显式传入时可覆盖环境配置(测试用非默认本地目录)。
"""
if not data:
raise FileUploadError(
"请选择要上传的文件", status_code=400, code="file_required"
)
limit = max_upload_size_bytes(settings)
if len(data) > limit:
raise FileUploadError(
f"文件不能超过 {limit // (1024 * 1024)}MB",
status_code=400,
code="file_too_large",
)
resolved_type = resolve_content_type(content_type, data)
if resolved_type not in ALLOWED_CONTENT_TYPES:
raise FileUploadError(
"文件不符合规则,仅支持 JPG、PNG、WebP 或 PDF",
status_code=400,
code="file_type_invalid",
)
resolved_scene = normalize_scene(scene)
object_key = build_object_key(resolved_scene, resolved_type, filename)
storage: ObjectStorage = get_object_storage(settings)
uploaded_keys: list[str] = []
try:
uploaded_keys.append(object_key)
storage.put_object(
key=object_key,
data=data,
content_type=resolved_type,
metadata={"original-filename": filename, "scene": resolved_scene},
)
thumbnail_key = ""
medium_key = ""
for variant in generate_image_variants(data, resolved_type):
variant_key = image_variant_key(
object_key, variant.name, _pick_extension(variant.content_type, "")
)
try:
storage.put_object(
key=variant_key,
data=variant.content,
content_type=variant.content_type,
metadata={"source-object": object_key},
)
except Exception as exc: # noqa: BLE001 变体失败不阻断上传
logger.warning(f"变体写入失败 key={variant_key}: {exc}")
continue
uploaded_keys.append(variant_key)
if variant.name == VARIANT_THUMB:
thumbnail_key = variant_key
elif variant.name == VARIANT_MEDIUM:
medium_key = variant_key
row = FileAsset(
object_key=object_key,
scene=resolved_scene,
original_filename=filename[:255],
content_type=resolved_type,
size_bytes=len(data),
thumbnail_object_key=thumbnail_key,
medium_object_key=medium_key,
uploader_type=str(uploader_type or "")[:32],
uploader_id=str(uploader_id or "")[:64],
status="active",
metadata_json={
"originalContentType": content_type or "",
"scene": resolved_scene,
},
)
db.add(row)
db.commit()
except FileUploadError:
raise
except Exception as exc:
db.rollback()
_cleanup_objects(storage, uploaded_keys)
logger.error(f"文件上传失败,已回滚对象: {exc}")
raise
return UploadedFile(
object_key=object_key,
url=build_file_url(object_key),
thumbnail_url=build_file_url(thumbnail_key or object_key),
medium_url=build_file_url(medium_key or object_key),
filename=filename,
content_type=resolved_type,
size=len(data),
)
def get_stored_object(object_key: Any, variant: Any = "") -> StoredObject:
"""读取对象(变体缺失自动回退原图)。"""
try:
key = normalize_object_key(object_key)
except ValueError as exc:
raise FileUploadError(
"文件 key 不正确", status_code=400, code="file_key_invalid"
) from exc
variant_name = str(variant or "").strip().lower()
candidates = (
image_variant_fallback_keys(key, variant_name) if variant_name else [key]
)
storage = get_object_storage()
for candidate in candidates:
try:
return storage.get_object(candidate)
except FileNotFoundError:
continue
raise FileUploadError(
"文件不存在或暂不可访问", status_code=404, code="file_not_found"
)
def _cleanup_objects(storage: ObjectStorage, keys: list[str]) -> None:
"""补偿删除:删不干净只告警,不再抛异常掩盖原始错误。"""
for key in keys:
try:
storage.delete_object(key)
except Exception as exc: # noqa: BLE001
logger.warning(f"上传失败后的对象清理未成功 key={key}: {exc}")
+434
View File
@@ -0,0 +1,434 @@
"""对象存储适配层:本地目录后端 + S3 兼容对象存储(阿里云 OSS / MinIO)。
约定对齐两个参考实现(order_site 的 ``apps/backend/src/services/file-storage/*``、
hfb_sys 的 ``backend/internal/modules/file/storage.go``):
- **服务端代理读写**:对外只暴露 ``/api/files/object?key=...``,不下发 OSS 直链,
也不发签名链接 —— 签名链接会被业务方原样存进库里,过期后到处裂图;
- **内网 endpoint**:ECS 与桶同地域时用 ``oss-<region>-internal.aliyuncs.com``,
免公网流量费且延迟低;
- **寻址风格**:阿里云 OSS 必须 virtual-host style,自建 MinIO 走 path-style;
- **S3 校验头**:OSS 的 S3 兼容层不认 botocore 默认的 CRC32 请求校验头,需要关掉。
boto3 只在真正走 OSS 时才导入:本地开发/测试用 ``local`` 后端,没装 boto3 也能跑。
"""
from __future__ import annotations
import hashlib
import io
import os
import threading
from dataclasses import dataclass
from datetime import UTC, datetime
from pathlib import Path
from typing import Any, BinaryIO, Protocol
from urllib.parse import quote, urlsplit
from loguru import logger
PROJECT_ROOT = Path(__file__).resolve().parents[3]
DEFAULT_LOCAL_ROOT = PROJECT_ROOT / "data" / "file_storage"
MAX_UPLOAD_SIZE_MB_DEFAULT = 10
class FileStorageError(RuntimeError):
"""对象存储不可用(配置缺失、依赖缺失或远端拒绝)。"""
class StorageUnavailableError(FileStorageError):
"""存储后端没有配置好或连不上,属于「暂时不可用」而非「文件不存在」。"""
@dataclass(frozen=True)
class StorageSettings:
"""从环境变量读到的存储配置。"""
mode: str
endpoint: str
bucket: str
access_key_id: str
secret_access_key: str
region: str
local_root: Path
max_upload_size_mb: int
@property
def is_remote(self) -> bool:
return self.mode == "oss"
@dataclass(frozen=True)
class StoredObject:
"""读取到的对象:调用方负责关闭 ``reader``。"""
reader: BinaryIO
content_type: str
size: int
etag: str = ""
last_modified: datetime | None = None
class ObjectStorage(Protocol):
"""存储后端接口。缺 key 一律抛 ``FileNotFoundError``。"""
def put_object(
self,
*,
key: str,
data: bytes,
content_type: str,
metadata: dict[str, str] | None = None,
) -> None: ...
def get_object(self, key: str) -> StoredObject: ...
def delete_object(self, key: str) -> None: ...
def ensure_ready(self) -> None: ...
def _env_int(name: str, default: int) -> int:
"""读取正整数环境变量,非法值回退到默认值。"""
try:
value = int(os.getenv(name, str(default)))
except ValueError:
return default
return value if value > 0 else default
def load_storage_settings() -> StorageSettings:
"""读取 ``OSS_*`` 环境变量。未知 mode 一律回退到 local。
变量名沿用仓库既有约定(compose 早已透传、生产 ``.env`` 里也已写入):
``OSS_ENDPOINT`` 用内网端点,``OSS_BUCKET`` 是本项目自己的桶。
"""
raw_mode = (os.getenv("OSS_MODE", "") or "").strip().lower()
mode = raw_mode if raw_mode in ("local", "oss") else "local"
endpoint = (os.getenv("OSS_ENDPOINT", "") or "").strip()
local_root = (os.getenv("OSS_LOCAL_ROOT", "") or "").strip()
region = (os.getenv("OSS_REGION", "") or "").strip() or _derive_region(endpoint)
return StorageSettings(
mode=mode,
endpoint=endpoint,
bucket=(os.getenv("OSS_BUCKET", "") or "").strip(),
access_key_id=(os.getenv("OSS_ACCESS_KEY_ID", "") or "").strip(),
secret_access_key=(os.getenv("OSS_ACCESS_KEY_SECRET", "") or "").strip(),
region=region,
local_root=Path(local_root) if local_root else DEFAULT_LOCAL_ROOT,
max_upload_size_mb=_env_int(
"OSS_MAX_UPLOAD_SIZE_MB", MAX_UPLOAD_SIZE_MB_DEFAULT
),
)
def _derive_region(endpoint: str) -> str:
"""从 endpoint 反推 region。
``oss-cn-hangzhou-internal.aliyuncs.com`` → ``oss-cn-hangzhou``。
生产 ``.env`` 只要求配 endpoint/bucket/AK 三项,但 sigv4 需要 region,
所以没显式配 ``OSS_REGION`` 时按端点推导,省一个必填项、也避免填错。
"""
if not endpoint:
return ""
candidate = endpoint if "//" in endpoint else f"//{endpoint}"
host = urlsplit(candidate).hostname or ""
label = host.split(".")[0]
if label.startswith("oss-") and label.endswith("-internal"):
return label[: -len("-internal")]
return label if label.startswith("oss-") else ""
def max_upload_size_bytes(settings: StorageSettings | None = None) -> int:
"""上传大小上限(字节)。"""
resolved = settings or load_storage_settings()
return max(1, resolved.max_upload_size_mb) * 1024 * 1024
def normalize_object_key(raw_key: Any) -> str:
"""归一化对象 key 并挡住路径穿越。
与 order_site 的 ``normalizeObjectKey`` 同一套判据:去掉前导斜杠,
出现 ``..`` 或反斜杠直接拒绝。
"""
key = str(raw_key or "").strip().lstrip("/")
if not key or ".." in key or "\\" in key:
raise ValueError("文件 key 不正确")
return key
class LocalObjectStorage:
"""本地目录后端:仅用于开发与测试,生产走 OSS。
内容类型按扩展名推断(本地模式下原图与变体的扩展名都由上传流程按 MIME 生成,
因此推断是可靠的);etag 用内容 md5,便于回读接口做 304。
"""
def __init__(self, root: Path):
self._root = Path(root)
@property
def root(self) -> Path:
return self._root
def _path_for(self, key: str) -> Path:
return self._root / normalize_object_key(key)
def ensure_ready(self) -> None:
self._root.mkdir(parents=True, exist_ok=True)
def put_object(
self,
*,
key: str,
data: bytes,
content_type: str,
metadata: dict[str, str] | None = None,
) -> None:
del content_type, metadata # 本地后端不保存对象元数据
path = self._path_for(key)
path.parent.mkdir(parents=True, exist_ok=True)
path.write_bytes(data)
def get_object(self, key: str) -> StoredObject:
path = self._path_for(key)
try:
data = path.read_bytes()
except FileNotFoundError as exc:
raise FileNotFoundError(key) from exc
return StoredObject(
reader=io.BytesIO(data),
content_type=_guess_content_type(path.name),
size=len(data),
etag=f'"{hashlib.md5(data).hexdigest()}"',
last_modified=datetime.fromtimestamp(path.stat().st_mtime, UTC),
)
def delete_object(self, key: str) -> None:
path = self._path_for(key)
try:
path.unlink()
except FileNotFoundError:
return
class S3ObjectStorage:
"""S3 兼容后端(阿里云 OSS / MinIO)。boto3 延迟导入。"""
def __init__(self, settings: StorageSettings):
self._settings = settings
self._client: Any = None
self._bucket_ready = False
self._lock = threading.Lock()
@property
def is_aliyun(self) -> bool:
return "aliyuncs.com" in self._settings.endpoint.lower()
def _build_client(self) -> Any:
settings = self._settings
if not (settings.endpoint and settings.bucket):
raise StorageUnavailableError(
"对象存储未配置:需要同时设置 OSS_ENDPOINT 与 OSS_BUCKET"
)
try:
import boto3
except ImportError as exc: # pragma: no cover - 取决于部署环境
raise StorageUnavailableError(
"缺少 boto3 依赖,无法使用 OSS 存储(执行 uv sync 安装后重启服务)"
) from exc
from botocore.config import Config as BotoConfig
addons: dict[str, Any] = {}
try:
# 新版 botocore 才支持这两个开关;旧版直接省略。
addons = {
"request_checksum_calculation": "when_required",
"response_checksum_validation": "when_required",
}
config = BotoConfig(
signature_version="s3v4",
s3={"addressing_style": "virtual" if self.is_aliyun else "path"},
retries={"max_attempts": 3, "mode": "standard"},
connect_timeout=_env_int("OSS_CONNECT_TIMEOUT", 5),
read_timeout=_env_int("OSS_READ_TIMEOUT", 30),
max_pool_connections=_env_int("OSS_MAX_POOL_CONNECTIONS", 20),
**addons,
)
except TypeError: # pragma: no cover - 仅旧版 botocore 走到
config = BotoConfig(
signature_version="s3v4",
s3={"addressing_style": "virtual" if self.is_aliyun else "path"},
)
return boto3.client(
"s3",
endpoint_url=_normalize_endpoint_url(settings.endpoint, self.is_aliyun),
aws_access_key_id=settings.access_key_id or None,
aws_secret_access_key=settings.secret_access_key or None,
region_name=settings.region or None,
config=config,
)
def _get_client(self) -> Any:
if self._client is None:
with self._lock:
if self._client is None:
self._client = self._build_client()
return self._client
def ensure_ready(self) -> None:
"""确保桶可用。
阿里云 OSS 的桶由控制台预先创建 —— HeadBucket 在 RAM 权限收紧时会 403
甚至挂起,所以直接跳过;自建 MinIO 才做「不存在就建」。
"""
if self._bucket_ready or self.is_aliyun:
self._bucket_ready = True
return
client = self._get_client()
with self._lock:
if self._bucket_ready:
return
try:
client.head_bucket(Bucket=self._settings.bucket)
except Exception as exc: # 兼容层错误码不规范,只能按形状兜底
if not _is_not_found(exc):
raise
client.create_bucket(Bucket=self._settings.bucket)
self._bucket_ready = True
def put_object(
self,
*,
key: str,
data: bytes,
content_type: str,
metadata: dict[str, str] | None = None,
) -> None:
self.ensure_ready()
try:
self._get_client().put_object(
Bucket=self._settings.bucket,
Key=normalize_object_key(key),
Body=data,
ContentType=content_type or "application/octet-stream",
**({"Metadata": _sanitize_metadata(metadata)} if metadata else {}),
)
except Exception as exc: # 边界统一转成存储异常
raise StorageUnavailableError(f"对象写入失败: {exc}") from exc
def get_object(self, key: str) -> StoredObject:
self.ensure_ready()
try:
output = self._get_client().get_object(
Bucket=self._settings.bucket, Key=normalize_object_key(key)
)
except Exception as exc: # 边界统一转成存储异常
if _is_not_found(exc):
raise FileNotFoundError(key) from exc
raise StorageUnavailableError(f"对象读取失败: {exc}") from exc
body = output.get("Body")
if body is None:
raise FileNotFoundError(key)
return StoredObject(
reader=body,
content_type=str(output.get("ContentType") or "application/octet-stream"),
size=int(output.get("ContentLength") or 0),
etag=str(output.get("ETag") or ""),
last_modified=output.get("LastModified"),
)
def delete_object(self, key: str) -> None:
self.ensure_ready()
try:
self._get_client().delete_object(
Bucket=self._settings.bucket, Key=normalize_object_key(key)
)
except Exception as exc: # noqa: BLE001 删除失败不该打断业务异常链
logger.warning(f"对象删除失败 key={key}: {exc}")
_storage: ObjectStorage | None = None
_storage_lock = threading.Lock()
def _build_storage(settings: StorageSettings) -> ObjectStorage:
"""按配置构造后端:oss → S3 兼容,其余 → 本地目录。"""
if settings.is_remote:
return S3ObjectStorage(settings)
return LocalObjectStorage(settings.local_root)
def get_object_storage(settings: StorageSettings | None = None) -> ObjectStorage:
"""返回当前配置对应的存储后端;显式传 settings 时不走单例(测试用)。"""
global _storage
if settings is not None:
return _build_storage(settings)
if _storage is None:
with _storage_lock:
if _storage is None:
_storage = _build_storage(load_storage_settings())
return _storage
def reset_object_storage_cache() -> None:
"""清空单例 —— 测试里切换 ``STORAGE_*`` 环境变量后调用。"""
global _storage
with _storage_lock:
_storage = None
def _guess_content_type(filename: str) -> str:
lowered = filename.lower()
if lowered.endswith((".jpg", ".jpeg")):
return "image/jpeg"
if lowered.endswith(".png"):
return "image/png"
if lowered.endswith(".webp"):
return "image/webp"
if lowered.endswith(".pdf"):
return "application/pdf"
return "application/octet-stream"
def _normalize_endpoint_url(endpoint: str, is_aliyun: bool) -> str:
"""补全 scheme:阿里云走 https,自建 MinIO 走 http。"""
candidate = endpoint.strip()
if not candidate:
raise StorageUnavailableError("对象存储 endpoint 未配置")
if not candidate.startswith(("http://", "https://")):
candidate = f"{'https' if is_aliyun else 'http'}://{candidate}"
parsed = urlsplit(candidate)
if not parsed.hostname:
raise StorageUnavailableError(f"对象存储 endpoint 不合法: {endpoint}")
return candidate.rstrip("/")
def _sanitize_metadata(metadata: dict[str, str] | None) -> dict[str, str]:
"""元数据会作为 HTTP header 下发,值统一转义为 ASCII(中文文件名否则会 400)。"""
if not metadata:
return {}
sanitized: dict[str, str] = {}
for raw_key, raw_value in metadata.items():
key = str(raw_key or "").strip()
if not key:
continue
sanitized[key] = quote(str(raw_value or ""), safe="")
return sanitized
def _is_not_found(error: Exception) -> bool:
"""把各兼容层形状不一的不存在错误统一识别出来。"""
code = getattr(error, "response", None)
if isinstance(code, dict):
error_code = str((code.get("Error") or {}).get("Code") or "")
status = (code.get("ResponseMetadata") or {}).get("HTTPStatusCode")
if error_code in ("404", "NoSuchKey", "NoSuchBucket", "NotFound"):
return True
if status == 404:
return True
return getattr(error, "name", "") in ("NotFound", "NoSuchKey")
File diff suppressed because it is too large Load Diff
+34 -13
View File
@@ -414,11 +414,22 @@ def persist_huya_session_cookie(
return True
def rebuild_web_cookie_from_raw(db: Session, account: HuyaAccount) -> str:
"""用 App 原始凭据重建网页运行 Cookie,不发起登录或支付。"""
raw = normalize_huya_cookie(account.raw_cookie or "")
def build_web_cookie_from_raw(
*,
uid: str = "",
yyuid: str = "",
username: str = "",
raw_cookie: str = "",
) -> str:
"""用 App 原始凭据生成网页运行 Cookie(**纯函数,不碰数据库**)。
从 ``rebuild_web_cookie_from_raw`` 抽出来,供不依赖 ``huya_accounts`` 的调用方
复用(例如虎牙外部 CK 协作台账)—— 与其把这段设备态补齐逻辑复制一份,
不如让两边共用一处。原函数的行为一行未改,只是改为调用这里。
"""
raw = normalize_huya_cookie(raw_cookie or "")
if not raw:
raise ValueError("该账号没有 App 原始凭据,无法重建网页 Cookie")
raise ValueError("没有 App 原始凭据,无法重建网页 Cookie")
from core.huya.cookie_utils import cookie_pairs
from core.huya.device_profile import _load_db, canonical_account_key
@@ -427,27 +438,37 @@ def rebuild_web_cookie_from_raw(db: Session, account: HuyaAccount) -> str:
qimei_feature_from_device_profile,
)
uid = 0
for candidate in (account.uid, account.yyuid, cookie_value(raw, "udb_uid")):
uid_value = 0
for candidate in (uid, yyuid, cookie_value(raw, "udb_uid")):
text = str(candidate or "").strip()
if text.isdigit():
uid = int(text)
uid_value = int(text)
break
feature = None
username = (account.username or "").strip()
if username:
account_name = (username or "").strip()
if account_name:
profiles = _load_db()
profile = profiles.get(canonical_account_key(username)) or profiles.get(
username
profile = profiles.get(canonical_account_key(account_name)) or profiles.get(
account_name
)
if profile:
feature = qimei_feature_from_device_profile(profile)
filled = fill_web_cookie_fields(raw, guid="", uid=uid, qimei_feature=feature)
filled = fill_web_cookie_fields(raw, guid="", uid=uid_value, qimei_feature=feature)
pairs = dict(cookie_pairs(filled))
pairs["udb_appid"] = "5002"
rebuilt = "; ".join(f"{key}={value}" for key, value in pairs.items())
return "; ".join(f"{key}={value}" for key, value in pairs.items())
def rebuild_web_cookie_from_raw(db: Session, account: HuyaAccount) -> str:
"""用 App 原始凭据重建网页运行 Cookie,不发起登录或支付。"""
rebuilt = build_web_cookie_from_raw(
uid=account.uid,
yyuid=account.yyuid,
username=account.username,
raw_cookie=account.raw_cookie,
)
account.cookie = rebuilt
account.status = "login_success"
account.updated_at = datetime.now(UTC)