fix(寄件): 取消独立存储配置并复用系统路径

寄件码只保存授权信息，新上传直接使用系统存储及原路径生成器；移除自定义存储目录接口和重复校验。迁移保留授权计数及历史文件、进行中会话的位置。

验证：原有后端测试 114 项通过、2 项跳过；内存数据库检查迁移幂等、系统配置跟随及旧文件定位；未新增测试文件。

Author: dawnstamp

apps/base/migrations/migrations_015.py

@@ -0,0 +1,42 @@
+"""删除寄件码独立存储配置；既有文件和上传会话的位置不变。"""
+
+from tortoise.transactions import in_transaction
+
+
+async def migrate():
+    # 重建仅授权数据的表，保留主键、计数和自增序列，不搬动任何已保存的文件。
+    async with in_transaction() as conn:
+        columns = {row["name"] for row in await conn.execute_query_dict("PRAGMA table_info(deliverycode)")}
+        if not {"storage_type", "target_path"} & columns:
+            return
+        sequences = await conn.execute_query_dict("SELECT seq FROM sqlite_sequence WHERE name = 'deliverycode'")
+        sequence = sequences[0]["seq"] if sequences else 0
+        await conn.execute_query('''
+            CREATE TABLE deliverycode_system_storage (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                code_value VARCHAR(64) NULL UNIQUE,
+                auth_version INT NOT NULL DEFAULT 1,
+                name VARCHAR(100) NOT NULL,
+                note VARCHAR(2000) NOT NULL DEFAULT '',
+                tags JSON NOT NULL DEFAULT '[]',
+                expires_at TIMESTAMP NOT NULL,
+                max_uploads INT NOT NULL,
+                used_count INT NOT NULL DEFAULT 0,
+                reserved_count INT NOT NULL DEFAULT 0,
+                enabled INT NOT NULL DEFAULT 1,
+                deleted INT NOT NULL DEFAULT 0,
+                created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+            )
+        ''')
+        await conn.execute_query('''
+            INSERT INTO deliverycode_system_storage (
+                id, code_value, auth_version, name, note, tags, expires_at,
+                max_uploads, used_count, reserved_count, enabled, deleted, created_at
+            ) SELECT id, code_value, auth_version, name, note, tags, expires_at,
+                max_uploads, used_count, reserved_count, enabled, deleted, created_at
+            FROM deliverycode
+        ''')
+        await conn.execute_query("DROP TABLE deliverycode")
+        await conn.execute_query("ALTER TABLE deliverycode_system_storage RENAME TO deliverycode")
+        # 不能因历史行曾被删除而复用旧 ID，避免错误接回历史收件关联。
+        await conn.execute_query("UPDATE sqlite_sequence SET seq = MAX(seq, ?) WHERE name = 'deliverycode'", [sequence])

apps/base/models.py

@@ -119,9 +119,6 @@ class DeliveryCode(models.Model):
     name = fields.CharField(max_length=100)
     note = fields.CharField(max_length=2000, default="")
     tags = fields.JSONField(default=list)
-    # system 仅标记寄件码跟随设置，实际收件记录始终保存解析后的存储类型与目录。
-    storage_type = fields.CharField(max_length=20)
-    target_path = fields.CharField(max_length=200)
     expires_at = fields.DatetimeField()
     max_uploads = fields.IntField()
     used_count = fields.IntField(default=0)

apps/base/upload_access.py

@@ -12,7 +12,6 @@
 from apps.delivery.services import upload_identity, active_code
 from core.settings import settings
 from core.storage import storages
-from apps.delivery.storage import get_storage
 from core.utils import get_now
 
 
@@ -89,7 +88,7 @@ async def prepare_upload(access, file_name, file_size, upload_id):
 
 async def upload_storage(access=None):
     if access is not None and access.record is not None:
-        return await get_storage(access.record.storage_type)
+        return storages[access.record.storage_type]()
     return storages[settings.file_storage]()
 
 

apps/base/upload_sessions.py

@@ -13,17 +13,14 @@
 from apps.base.utils import build_file_path
 from core.logger import logger
 from core.settings import settings
-from core.storage import StoredFile
-from apps.delivery.storage import get_storage, validate_storage_config
-from core.utils import get_now, sanitize_filename
+from core.storage import StoredFile, storages
+from core.utils import get_now
 
 STALE_SECONDS = 7200
 
 
 async def reserve_slot(code_id, version, file_name, upload_id):
     """次数原子预占与会话创建同事务；实际字节随后由共用配额入口预留。"""
-    filename = await sanitize_filename((file_name or "file").replace("\\", "/").split("/")[-1])
-    filename = filename.encode("utf-8")[:180].decode("utf-8", errors="ignore") or "file"
     async with in_transaction() as conn:
         now = await get_now()
         p = _sql_placeholders(3)
@@ -35,18 +32,13 @@ async def reserve_slot(code_id, version, file_name, upload_id):
         )
         if changed != 1:
             raise HTTPException(409, "寄件码已失效或没有剩余上传次数")
-        code = await DeliveryCode.get(id=code_id).using_db(conn)
-        storage_type, path = code.storage_type, code.target_path
-        if storage_type == "system":
-            storage_type = settings.file_storage
-            path, *_ = await build_file_path("delivery", upload_id)
-        validate_storage_config(storage_type)
+        # 每次新寄件都沿用原系统的存储设置和路径生成器，不读取寄件码独立配置。
+        storage_type = settings.file_storage
+        path, _, _, stored_name, _ = await build_file_path(file_name or "file", upload_id)
         token = "d_" + upload_id
-        if code.storage_type != "system":
-            path = f"{path}/{token}"
         return await StorageReservation.create(
             token=token, size=0, delivery_id=code_id, auth_version=version,
-            filename=filename, stored_name=token + "_" + filename,
+            filename=stored_name, stored_name=stored_name,
             file_path=path, storage_type=storage_type,
             expires_at=now + timedelta(seconds=STALE_SECONDS), using_db=conn,
         )
@@ -87,7 +79,7 @@ async def clean_reservation(record_id):
     if record is None:
         return
     try:
-        storage = await get_storage(record.storage_type)
+        storage = storages[record.storage_type]()
         if record.stored_name:
             path = f"{record.file_path}/{record.stored_name}"
             await storage.clean_chunks(record.token, path)
@@ -131,7 +123,7 @@ async def cleanup_once():
     tokens = await UploadChunk.filter(chunk_index=-1, upload_id__startswith="d_").limit(100).values_list("upload_id", flat=True)
     for share in await FileCodes.filter(upload_id__in=tokens):
         try:
-            storage = await get_storage(share.storage_type)
+            storage = storages[share.storage_type]()
             await storage.clean_chunks(share.upload_id, await share.get_file_path())
             await UploadChunk.filter(upload_id=share.upload_id).delete()
         except Exception:

apps/delivery/schemas.py

@@ -1,4 +1,4 @@
-"""寄件参数校验，所有路径都相对于已配置的存储根目录。"""
+"""只校验寄件授权参数，存储和文件规则由系统设置统一控制。"""
 
 import re
 from datetime import datetime, timezone, timedelta
@@ -7,34 +7,16 @@
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
 from apps.base.metadata import normalize_metadata_note, normalize_metadata_tags
-from core.path_validation import validate_storage_directory
 
 
 class DeliveryCodeConfig(BaseModel):
-    """创建和编辑共用配置校验，编辑请求不能改动口令或计数。"""
+    """寄件授权的公共字段，文件和存储配置不在此模型中。"""
     # 禁止静默接受 owner_id 等越权字段，未来多用户必须由服务端身份决定归属。
     model_config = ConfigDict(extra="forbid", str_strip_whitespace=True)
     name: str = Field(min_length=1, max_length=100)
-    # system 表示上传开始时跟随全站配置；旧记录的明确存储值继续保留。
-    storage_type: str = "system"
-    target_path: str = Field(default="", max_length=200)
     expires_at: datetime
     max_uploads: int = Field(default=1, ge=1, le=100000)
 
-    @field_validator("storage_type")
-    @classmethod
-    def validate_storage(cls, value):
-        # 配置入口与设置页保持一致；历史收件的存储驱动仍保留供读取和清理。
-        if value not in {"system", "local", "s3", "webdav"}:
-            raise ValueError("不支持的存储类型")
-        return value
-
-    @field_validator("target_path")
-    @classmethod
-    def validate_path(cls, value):
-        # 目录校验与系统设置共用，避免同一路径在两个入口产生不同结果。
-        return validate_storage_directory(value, allow_empty=True, max_length=200)
-
     @field_validator("expires_at")
     @classmethod
     def validate_expiry(cls, value):
@@ -45,15 +27,6 @@ def validate_expiry(cls, value):
             raise ValueError("有效期必须晚于当前时间")
         return value
 
-    @model_validator(mode="after")
-    def validate_storage_mode(self):
-        # 跟随系统时不保存隐藏表单中残留的自定义目录。
-        if self.storage_type == "system":
-            self.target_path = ""
-        elif not self.target_path:
-            raise ValueError("自定义存储位置必须填写目标目录")
-        return self
-
 
 class CreateDeliveryCode(DeliveryCodeConfig):
     # 新建自定义寄件码最多 32 位；自动生成仍固定为 16 位。
@@ -85,26 +58,12 @@ class UpdateDeliveryCode(BaseModel):
 
     model_config = ConfigDict(extra="forbid", str_strip_whitespace=True)
     name: str | None = Field(default=None, min_length=1, max_length=100)
-    storage_type: str | None = None
-    target_path: str | None = Field(default=None, max_length=200)
     expires_at: datetime | None = None
     max_uploads: int | None = Field(default=None, ge=1, le=100000)
     code: str = Field(default="", max_length=32)
     note: str | None = Field(default=None, max_length=2000)
     tags: list[str] | None = None
 
-    @field_validator("storage_type")
-    @classmethod
-    def validate_storage(cls, value):
-        if value is not None and value not in {"system", "local", "s3", "webdav"}:
-            raise ValueError("不支持的存储类型")
-        return value
-
-    @field_validator("target_path")
-    @classmethod
-    def validate_path(cls, value):
-        return None if value is None else validate_storage_directory(value, allow_empty=True, max_length=200)
-
     @field_validator("code")
     @classmethod
     def validate_code(cls, value):
@@ -131,7 +90,7 @@ def normalize_tags(cls, value):
     @model_validator(mode="after")
     def reject_explicit_null(self):
         # 可选字段表示可以省略，不能用 null 意外清空已有配置。
-        forbidden = {"name", "storage_type", "target_path", "expires_at", "max_uploads", "note", "tags"}
+        forbidden = {"name", "expires_at", "max_uploads", "note", "tags"}
         if any(field in self.model_fields_set and getattr(self, field) is None for field in forbidden):
             raise ValueError("编辑字段不能为 null；请省略不修改的字段")
         return self

apps/delivery/services.py

@@ -11,8 +11,7 @@
 from apps.admin.dependencies import create_token, verify_token
 from apps.base.models import DeliveryCode, StorageReservation
 from apps.base.quota import _sql_placeholders
-from apps.delivery.storage import validate_storage_config
-from core.settings import settings
+from apps.base.setup_wizard import build_public_config
 from core.utils import get_now
 
 TOKEN_TTL = 900
@@ -46,12 +45,10 @@ async def active_code(code_id: int) -> DeliveryCode:
 
 async def create_code(data):
     """创建时保存原文，便于管理员后续查看；访客响应仍不提供任何口令列表。"""
-    validate_storage_config(settings.file_storage if data.storage_type == "system" else data.storage_type)
     code = data.code or "".join(secrets.choice("ABCDEFGHJKLMNPQRSTUVWXYZ23456789") for _ in range(16))
     try:
         record = await DeliveryCode.create(
             code_value=code, name=data.name,
-            storage_type=data.storage_type, target_path=data.target_path,
             expires_at=data.expires_at, max_uploads=data.max_uploads,
             note=data.note, tags=data.tags,
         )
@@ -73,10 +70,10 @@ async def code_summary(record, *, include_code=False):
     elif record.expires_at <= now:
         state = "expired"
     return {
-        "id": record.id, "name": record.name, "storage_type": record.storage_type,
+        "id": record.id, "name": record.name,
         **({"code": record.code_value} if include_code else {}),
         "note": record.note, "tags": record.tags if isinstance(record.tags, list) else [],
-        "target_path": record.target_path, "expires_at": record.expires_at,
+        "expires_at": record.expires_at,
         "max_uploads": record.max_uploads, "used_count": record.used_count,
         "reserved_count": record.reserved_count, "enabled": record.enabled,
         "deleted": record.deleted, "status": state, "created_at": record.created_at,
@@ -98,14 +95,16 @@ async def verify_code(code: str):
 
 async def session_summary(record):
     """验证与续期使用相同白名单响应，不泄露路径、存储密钥或管理员授权。"""
+    # 老版寄件页面仍读取这些字段；值统一取自原公共配置构建函数，不维护独立规则。
+    config = build_public_config()
+    upload_keys = ("upload_size", "allowed_file_types", "expire_style", "max_save_seconds", "enable_chunk")
     return {
         "token": create_token({"purpose": "delivery", "delivery_id": record.id,
                                "delivery_version": record.auth_version}, expires_in=TOKEN_TTL),
         "expires_in": TOKEN_TTL, "name": record.name,
         "remaining": max(0, record.max_uploads - record.used_count - record.reserved_count),
-        "expires_at": record.expires_at, "upload_size": settings.upload_size,
-        "allowed_file_types": settings.allowed_file_types, "expire_style": settings.expire_style,
-        "max_save_seconds": settings.max_save_seconds, "enable_chunk": settings.enable_chunk,
+        "expires_at": record.expires_at,
+        **{key: config[key] for key in upload_keys},
     }
 
 
@@ -135,18 +134,6 @@ async def update_code(code_id, data):
         max_uploads = changes.get("max_uploads", record.max_uploads)
         if record.used_count + record.reserved_count > max_uploads:
             raise HTTPException(409, "上传总次数不能小于已使用次数与上传中占用次数之和，请刷新后重试")
-        storage_requested = "storage_type" in changes or "target_path" in changes
-        storage_type = changes.get("storage_type", record.storage_type)
-        target_path = changes.get("target_path", record.target_path)
-        if storage_type == "system":
-            target_path = ""
-        elif not target_path:
-            raise HTTPException(400, "自定义存储位置必须填写目标目录")
-        # 整理名称或元数据时不依赖当前后端配置；仅实际改存储设置才重新校验。
-        if storage_requested and (storage_type != record.storage_type or target_path != record.target_path):
-            validate_storage_config(settings.file_storage if storage_type == "system" else storage_type)
-            changes["storage_type"] = storage_type
-            changes["target_path"] = target_path
         if new_code and new_code != record.code_value:
             # 版本由数据库递增，两个改码请求并发时任一旧令牌都不会被错误复用。
             changes.update(code_value=new_code, auth_version=True)
@@ -173,12 +160,10 @@ async def update_code(code_id, data):
         return await code_summary(record)
 
 
-async def list_codes(*, page=1, page_size=20, keyword="", status="all", storage_type="all", tag="", sort_by="created_at", sort_order="desc"):
+async def list_codes(*, page=1, page_size=20, keyword="", status="all", tag="", sort_by="created_at", sort_order="desc"):
     """筛选、计数、排序和分页全部在数据库执行，列表不返回口令原文。"""
     if status not in {"all", "active", "disabled", "expired", "exhausted"}:
         raise HTTPException(400, "不支持的寄件码状态筛选")
-    if storage_type not in {"all", "system", "local", "s3", "webdav"}:
-        raise HTTPException(400, "不支持的存储类型筛选")
     if sort_by not in {"created_at", "expires_at", "name", "used_count", "max_uploads"} or sort_order not in {"asc", "desc"}:
         raise HTTPException(400, "不支持的排序方式")
     query = DeliveryCode.filter(deleted=False)
@@ -191,8 +176,6 @@ async def list_codes(*, page=1, page_size=20, keyword="", status="all", storage_
         query = query.filter(enabled=True, expires_at__lte=now, used_count__lt=F("max_uploads"))
     elif status == "active":
         query = query.filter(enabled=True, expires_at__gt=now, used_count__lt=F("max_uploads"))
-    if storage_type != "all":
-        query = query.filter(storage_type=storage_type)
     if keyword.strip():
         query = query.filter(Q(name__icontains=keyword.strip()) | Q(note__icontains=keyword.strip()))
     if tag.strip():
@@ -206,7 +189,7 @@ async def list_codes(*, page=1, page_size=20, keyword="", status="all", storage_
     order = ("-" if sort_order == "desc" else "") + sort_by
     # 只选取管理展示字段，口令原文仅由单独管理接口按需返回。
     records = await query.order_by(order, "-id").offset((page - 1) * page_size).limit(page_size).only(
-        "id", "name", "note", "tags", "storage_type", "target_path", "expires_at",
+        "id", "name", "note", "tags", "expires_at",
         "max_uploads", "used_count", "reserved_count", "enabled", "deleted", "created_at",
     )
     return {"items": [await code_summary(record) for record in records], "total": total}

apps/delivery/storage.py

@@ -47,10 +47,10 @@ async def refresh(authorization: str | None = Header(default=None)):
 @admin_api.get("/codes")
 async def list_codes(
     page: int = Query(1, ge=1), page_size: int = Query(20, ge=1, le=100), keyword: str = "",
-    status: str = "all", storage_type: str = "all", tag: str = "", sort_by: str = "created_at", sort_order: str = "desc",
+    status: str = "all", tag: str = "", sort_by: str = "created_at", sort_order: str = "desc",
 ):
     return APIResponse(detail=await services.list_codes(
-        page=page, page_size=page_size, keyword=keyword, status=status, storage_type=storage_type,
+        page=page, page_size=page_size, keyword=keyword, status=status,
         tag=tag, sort_by=sort_by, sort_order=sort_order,
     ))