于小丘
ccadfe57cd
All checks were successful
Test / test (push) Successful in 1m45s
- Migrate SQLModel base classes, mixins, and database management to external sqlmodel-ext package; remove sqlmodels/base/, sqlmodels/mixin/, and sqlmodels/database.py - Add file viewer/editor system with WOPI protocol support for collaborative editing (OnlyOffice, Collabora) - Add enterprise edition license verification module (ee/) - Add Dockerfile multi-stage build with Cython compilation support - Add new dependencies: sqlmodel-ext, cryptography, whatthepatch Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
1005 lines
31 KiB
Python
1005 lines
31 KiB
Python
"""
|
||
文件操作路由
|
||
|
||
提供文件上传、下载、创建等核心功能。
|
||
|
||
路由结构：
|
||
- /file - 文件操作
|
||
- /file/upload - 上传相关操作
|
||
- /file/download - 下载相关操作
|
||
"""
|
||
import hashlib
|
||
from datetime import datetime, timedelta
|
||
from typing import Annotated
|
||
from uuid import UUID
|
||
|
||
import whatthepatch
|
||
from fastapi import APIRouter, Depends, File, HTTPException, UploadFile
|
||
from fastapi.responses import FileResponse
|
||
from loguru import logger as l
|
||
from sqlmodel_ext import SQLModelBase
|
||
from whatthepatch.exceptions import HunkApplyException
|
||
|
||
from middleware.auth import auth_required, verify_download_token
|
||
from middleware.dependencies import SessionDep
|
||
from sqlmodels import (
|
||
CreateFileRequest,
|
||
CreateUploadSessionRequest,
|
||
FileApp,
|
||
FileAppExtension,
|
||
FileAppGroupLink,
|
||
FileAppType,
|
||
Object,
|
||
ObjectType,
|
||
PhysicalFile,
|
||
Policy,
|
||
PolicyType,
|
||
ResponseBase,
|
||
Setting,
|
||
SettingsType,
|
||
UploadChunkResponse,
|
||
UploadSession,
|
||
UploadSessionResponse,
|
||
User,
|
||
WopiSessionResponse,
|
||
)
|
||
from service.storage import LocalStorageService, adjust_user_storage
|
||
from utils.JWT import create_download_token, DOWNLOAD_TOKEN_TTL
|
||
from utils.JWT.wopi_token import create_wopi_token
|
||
from utils import http_exceptions
|
||
from .viewers import viewers_router
|
||
|
||
|
||
# DTO
|
||
|
||
class DownloadTokenModel(ResponseBase):
|
||
"""下载Token响应模型"""
|
||
|
||
access_token: str
|
||
"""JWT 令牌"""
|
||
|
||
expires_in: int
|
||
"""过期时间（秒）"""
|
||
|
||
|
||
class TextContentResponse(ResponseBase):
|
||
"""文本文件内容响应"""
|
||
|
||
content: str
|
||
"""文件文本内容（UTF-8）"""
|
||
|
||
hash: str
|
||
"""SHA-256 hex"""
|
||
|
||
size: int
|
||
"""文件字节大小"""
|
||
|
||
|
||
class PatchContentRequest(SQLModelBase):
|
||
"""增量保存请求"""
|
||
|
||
patch: str
|
||
"""unified diff 文本"""
|
||
|
||
base_hash: str
|
||
"""原始内容的 SHA-256 hex（64字符）"""
|
||
|
||
|
||
class PatchContentResponse(ResponseBase):
|
||
"""增量保存响应"""
|
||
|
||
new_hash: str
|
||
"""新内容的 SHA-256 hex"""
|
||
|
||
new_size: int
|
||
"""新文件字节大小"""
|
||
|
||
# ==================== 主路由 ====================
|
||
|
||
router = APIRouter(prefix="/file", tags=["file"])
|
||
|
||
|
||
# ==================== 上传子路由 ====================
|
||
|
||
_upload_router = APIRouter(prefix="/upload")
|
||
|
||
|
||
@_upload_router.put(
|
||
path='/',
|
||
summary='创建上传会话',
|
||
description='创建文件上传会话，返回会话ID用于后续分片上传。',
|
||
)
|
||
async def create_upload_session(
|
||
session: SessionDep,
|
||
user: Annotated[User, Depends(auth_required)],
|
||
request: CreateUploadSessionRequest,
|
||
) -> UploadSessionResponse:
|
||
"""
|
||
创建上传会话端点
|
||
|
||
流程：
|
||
1. 验证父目录存在且属于当前用户
|
||
2. 确定存储策略（使用指定的或继承父目录的）
|
||
3. 验证文件大小限制
|
||
4. 创建上传会话并生成存储路径
|
||
5. 返回会话信息
|
||
"""
|
||
# 验证文件名
|
||
if not request.file_name or '/' in request.file_name or '\\' in request.file_name:
|
||
raise HTTPException(status_code=400, detail="无效的文件名")
|
||
|
||
# 验证父目录（排除已删除的）
|
||
parent = await Object.get(
|
||
session,
|
||
(Object.id == request.parent_id) & (Object.deleted_at == None)
|
||
)
|
||
if not parent or parent.owner_id != user.id:
|
||
raise HTTPException(status_code=404, detail="父目录不存在")
|
||
|
||
if not parent.is_folder:
|
||
raise HTTPException(status_code=400, detail="父对象不是目录")
|
||
|
||
if parent.is_banned:
|
||
http_exceptions.raise_banned("目标目录已被封禁，无法执行此操作")
|
||
|
||
# 确定存储策略
|
||
policy_id = request.policy_id or parent.policy_id
|
||
policy = await Policy.get(session, Policy.id == policy_id)
|
||
if not policy:
|
||
raise HTTPException(status_code=404, detail="存储策略不存在")
|
||
|
||
# 验证文件大小限制
|
||
if policy.max_size > 0 and request.file_size > policy.max_size:
|
||
raise HTTPException(
|
||
status_code=413,
|
||
detail=f"文件大小超过限制 ({policy.max_size} bytes)"
|
||
)
|
||
|
||
# 检查存储配额（auth_required 已预加载 user.group）
|
||
max_storage = user.group.max_storage
|
||
if max_storage > 0 and user.storage + request.file_size > max_storage:
|
||
http_exceptions.raise_insufficient_quota("存储空间不足")
|
||
|
||
# 检查是否已存在同名文件（仅检查未删除的）
|
||
existing = await Object.get(
|
||
session,
|
||
(Object.owner_id == user.id) &
|
||
(Object.parent_id == parent.id) &
|
||
(Object.name == request.file_name) &
|
||
(Object.deleted_at == None)
|
||
)
|
||
if existing:
|
||
raise HTTPException(status_code=409, detail="同名文件已存在")
|
||
|
||
# 计算分片信息
|
||
options = await policy.awaitable_attrs.options
|
||
chunk_size = options.chunk_size if options else 52428800 # 默认 50MB
|
||
total_chunks = max(1, (request.file_size + chunk_size - 1) // chunk_size) if request.file_size > 0 else 1
|
||
|
||
# 生成存储路径
|
||
storage_path: str | None = None
|
||
if policy.type == PolicyType.LOCAL:
|
||
storage_service = LocalStorageService(policy)
|
||
dir_path, storage_name, full_path = await storage_service.generate_file_path(
|
||
user_id=user.id,
|
||
original_filename=request.file_name,
|
||
)
|
||
storage_path = full_path
|
||
else:
|
||
raise HTTPException(status_code=501, detail="S3 存储暂未实现")
|
||
|
||
# 创建上传会话
|
||
upload_session = UploadSession(
|
||
file_name=request.file_name,
|
||
file_size=request.file_size,
|
||
chunk_size=chunk_size,
|
||
total_chunks=total_chunks,
|
||
storage_path=storage_path,
|
||
expires_at=datetime.now() + timedelta(hours=24),
|
||
owner_id=user.id,
|
||
parent_id=request.parent_id,
|
||
policy_id=policy_id,
|
||
)
|
||
upload_session = await upload_session.save(session)
|
||
|
||
l.info(f"创建上传会话: {upload_session.id}, 文件: {request.file_name}, 大小: {request.file_size}")
|
||
|
||
return UploadSessionResponse(
|
||
id=upload_session.id,
|
||
file_name=upload_session.file_name,
|
||
file_size=upload_session.file_size,
|
||
chunk_size=upload_session.chunk_size,
|
||
total_chunks=upload_session.total_chunks,
|
||
uploaded_chunks=0,
|
||
expires_at=upload_session.expires_at,
|
||
)
|
||
|
||
|
||
@_upload_router.post(
|
||
path='/{session_id}/{chunk_index}',
|
||
summary='上传文件分片',
|
||
description='上传指定分片，分片索引从0开始。',
|
||
)
|
||
async def upload_chunk(
|
||
session: SessionDep,
|
||
user: Annotated[User, Depends(auth_required)],
|
||
session_id: UUID,
|
||
chunk_index: int,
|
||
file: UploadFile = File(...),
|
||
) -> UploadChunkResponse:
|
||
"""
|
||
上传文件分片端点
|
||
|
||
流程：
|
||
1. 验证上传会话
|
||
2. 写入分片数据
|
||
3. 更新会话进度
|
||
4. 如果所有分片上传完成，创建 Object 记录
|
||
"""
|
||
# 获取上传会话
|
||
upload_session = await UploadSession.get(session, UploadSession.id == session_id)
|
||
if not upload_session or upload_session.owner_id != user.id:
|
||
raise HTTPException(status_code=404, detail="上传会话不存在")
|
||
|
||
if upload_session.is_expired:
|
||
raise HTTPException(status_code=400, detail="上传会话已过期")
|
||
|
||
# 存储 user.id，避免后续 save() 导致 user 过期后无法访问
|
||
user_id = user.id
|
||
|
||
if chunk_index < 0 or chunk_index >= upload_session.total_chunks:
|
||
raise HTTPException(status_code=400, detail="无效的分片索引")
|
||
|
||
# 获取策略
|
||
policy = await Policy.get(session, Policy.id == upload_session.policy_id)
|
||
if not policy:
|
||
raise HTTPException(status_code=500, detail="存储策略不存在")
|
||
|
||
# 读取分片内容
|
||
content = await file.read()
|
||
|
||
# 写入分片
|
||
if policy.type == PolicyType.LOCAL:
|
||
if not upload_session.storage_path:
|
||
raise HTTPException(status_code=500, detail="存储路径丢失")
|
||
|
||
storage_service = LocalStorageService(policy)
|
||
offset = chunk_index * upload_session.chunk_size
|
||
await storage_service.write_file_chunk(
|
||
upload_session.storage_path,
|
||
content,
|
||
offset,
|
||
)
|
||
else:
|
||
raise HTTPException(status_code=501, detail="S3 存储暂未实现")
|
||
|
||
# 更新会话进度
|
||
upload_session.uploaded_chunks += 1
|
||
upload_session.uploaded_size += len(content)
|
||
upload_session = await upload_session.save(session)
|
||
|
||
# 在后续可能的 commit 前保存需要的属性
|
||
is_complete = upload_session.is_complete
|
||
uploaded_chunks = upload_session.uploaded_chunks
|
||
total_chunks = upload_session.total_chunks
|
||
file_object_id: UUID | None = None
|
||
|
||
if is_complete:
|
||
# 保存 upload_session 属性（commit 后会过期）
|
||
file_name = upload_session.file_name
|
||
uploaded_size = upload_session.uploaded_size
|
||
storage_path = upload_session.storage_path
|
||
upload_session_id = upload_session.id
|
||
parent_id = upload_session.parent_id
|
||
policy_id = upload_session.policy_id
|
||
|
||
# 创建 PhysicalFile 记录
|
||
physical_file = PhysicalFile(
|
||
storage_path=storage_path,
|
||
size=uploaded_size,
|
||
policy_id=policy_id,
|
||
reference_count=1,
|
||
)
|
||
physical_file = await physical_file.save(session, commit=False)
|
||
|
||
# 创建 Object 记录
|
||
file_object = Object(
|
||
name=file_name,
|
||
type=ObjectType.FILE,
|
||
size=uploaded_size,
|
||
physical_file_id=physical_file.id,
|
||
upload_session_id=str(upload_session_id),
|
||
parent_id=parent_id,
|
||
owner_id=user_id,
|
||
policy_id=policy_id,
|
||
)
|
||
file_object = await file_object.save(session, commit=False)
|
||
file_object_id = file_object.id
|
||
|
||
# 删除上传会话（使用条件删除）
|
||
await UploadSession.delete(
|
||
session,
|
||
condition=UploadSession.id == upload_session_id,
|
||
commit=False
|
||
)
|
||
|
||
# 更新用户存储配额
|
||
if uploaded_size > 0:
|
||
await adjust_user_storage(session, user_id, uploaded_size, commit=False)
|
||
|
||
# 统一提交所有更改
|
||
await session.commit()
|
||
|
||
l.info(f"文件上传完成: {file_name}, size={uploaded_size}, id={file_object_id}")
|
||
|
||
return UploadChunkResponse(
|
||
uploaded_chunks=uploaded_chunks if not is_complete else total_chunks,
|
||
total_chunks=total_chunks,
|
||
is_complete=is_complete,
|
||
object_id=file_object_id,
|
||
)
|
||
|
||
|
||
@_upload_router.delete(
|
||
path='/{session_id}',
|
||
summary='删除上传会话',
|
||
description='取消上传并删除会话及已上传的临时文件。',
|
||
)
|
||
async def delete_upload_session(
|
||
session: SessionDep,
|
||
user: Annotated[User, Depends(auth_required)],
|
||
session_id: UUID,
|
||
) -> ResponseBase:
|
||
"""删除上传会话端点"""
|
||
upload_session = await UploadSession.get(session, UploadSession.id == session_id)
|
||
if not upload_session or upload_session.owner_id != user.id:
|
||
raise HTTPException(status_code=404, detail="上传会话不存在")
|
||
|
||
# 删除临时文件
|
||
policy = await Policy.get(session, Policy.id == upload_session.policy_id)
|
||
if policy and policy.type == PolicyType.LOCAL and upload_session.storage_path:
|
||
storage_service = LocalStorageService(policy)
|
||
await storage_service.delete_file(upload_session.storage_path)
|
||
|
||
# 删除会话记录
|
||
await UploadSession.delete(session, upload_session)
|
||
|
||
l.info(f"删除上传会话: {session_id}")
|
||
|
||
return ResponseBase(data={"deleted": True})
|
||
|
||
|
||
@_upload_router.delete(
|
||
path='/',
|
||
summary='清除所有上传会话',
|
||
description='清除当前用户的所有上传会话。',
|
||
)
|
||
async def clear_upload_sessions(
|
||
session: SessionDep,
|
||
user: Annotated[User, Depends(auth_required)],
|
||
) -> ResponseBase:
|
||
"""清除所有上传会话端点"""
|
||
# 获取所有会话
|
||
sessions = await UploadSession.get(
|
||
session,
|
||
UploadSession.owner_id == user.id,
|
||
fetch_mode="all"
|
||
)
|
||
|
||
deleted_count = 0
|
||
for upload_session in sessions:
|
||
# 删除临时文件
|
||
policy = await Policy.get(session, Policy.id == upload_session.policy_id)
|
||
if policy and policy.type == PolicyType.LOCAL and upload_session.storage_path:
|
||
storage_service = LocalStorageService(policy)
|
||
await storage_service.delete_file(upload_session.storage_path)
|
||
|
||
await UploadSession.delete(session, upload_session)
|
||
deleted_count += 1
|
||
|
||
l.info(f"清除用户 {user.id} 的所有上传会话，共 {deleted_count} 个")
|
||
|
||
return ResponseBase(data={"deleted": deleted_count})
|
||
|
||
|
||
@_upload_router.get(
|
||
path='/archive/{session_id}/archive.zip',
|
||
summary='打包并下载文件',
|
||
description='获取打包后的文件。',
|
||
)
|
||
async def download_archive(session_id: str) -> ResponseBase:
|
||
"""打包下载"""
|
||
raise HTTPException(status_code=501, detail="打包下载功能暂未实现")
|
||
|
||
|
||
# ==================== 下载子路由 ====================
|
||
|
||
_download_router = APIRouter(prefix="/download")
|
||
|
||
|
||
@_download_router.post(
|
||
path='/{file_id}',
|
||
summary='创建下载令牌',
|
||
description='为指定文件创建下载令牌（JWT），有效期1小时。',
|
||
)
|
||
async def create_download_token_endpoint(
|
||
session: SessionDep,
|
||
user: Annotated[User, Depends(auth_required)],
|
||
file_id: UUID,
|
||
) -> DownloadTokenModel:
|
||
"""
|
||
创建下载令牌端点
|
||
|
||
验证文件存在且属于当前用户后，生成 JWT 下载令牌。
|
||
"""
|
||
file_obj = await Object.get(
|
||
session,
|
||
(Object.id == file_id) & (Object.deleted_at == None)
|
||
)
|
||
if not file_obj or file_obj.owner_id != user.id:
|
||
raise HTTPException(status_code=404, detail="文件不存在")
|
||
|
||
if not file_obj.is_file:
|
||
raise HTTPException(status_code=400, detail="对象不是文件")
|
||
|
||
if file_obj.is_banned:
|
||
http_exceptions.raise_banned()
|
||
|
||
token = create_download_token(file_id, user.id)
|
||
|
||
l.debug(f"创建下载令牌: file_id={file_id}, user_id={user.id}")
|
||
|
||
return DownloadTokenModel(access_token=token, expires_in=int(DOWNLOAD_TOKEN_TTL.total_seconds()))
|
||
|
||
|
||
@_download_router.get(
|
||
path='/{token}',
|
||
summary='下载文件',
|
||
description='使用下载令牌下载文件，令牌在有效期内可重复使用。',
|
||
)
|
||
async def download_file(
|
||
session: SessionDep,
|
||
token: str,
|
||
) -> FileResponse:
|
||
"""
|
||
下载文件端点
|
||
|
||
验证 JWT 令牌后返回文件内容。
|
||
令牌在有效期内可重复使用（支持浏览器 range 请求等场景）。
|
||
"""
|
||
# 验证令牌
|
||
result = verify_download_token(token)
|
||
if not result:
|
||
raise HTTPException(status_code=401, detail="下载令牌无效或已过期")
|
||
|
||
_, file_id, owner_id = result
|
||
|
||
# 获取文件对象（排除已删除的）
|
||
file_obj = await Object.get(
|
||
session,
|
||
(Object.id == file_id) & (Object.deleted_at == None)
|
||
)
|
||
if not file_obj or file_obj.owner_id != owner_id:
|
||
raise HTTPException(status_code=404, detail="文件不存在")
|
||
|
||
if not file_obj.is_file:
|
||
raise HTTPException(status_code=400, detail="对象不是文件")
|
||
|
||
if file_obj.is_banned:
|
||
http_exceptions.raise_banned()
|
||
|
||
# 预加载 physical_file 关系以获取存储路径
|
||
physical_file = await file_obj.awaitable_attrs.physical_file
|
||
if not physical_file or not physical_file.storage_path:
|
||
raise HTTPException(status_code=500, detail="文件存储路径丢失")
|
||
|
||
storage_path = physical_file.storage_path
|
||
|
||
# 获取策略
|
||
policy = await Policy.get(session, Policy.id == file_obj.policy_id)
|
||
if not policy:
|
||
raise HTTPException(status_code=500, detail="存储策略不存在")
|
||
|
||
if policy.type == PolicyType.LOCAL:
|
||
storage_service = LocalStorageService(policy)
|
||
if not await storage_service.file_exists(storage_path):
|
||
raise HTTPException(status_code=404, detail="物理文件不存在")
|
||
|
||
return FileResponse(
|
||
path=storage_path,
|
||
filename=file_obj.name,
|
||
media_type="application/octet-stream",
|
||
)
|
||
else:
|
||
raise HTTPException(status_code=501, detail="S3 存储暂未实现")
|
||
|
||
|
||
# ==================== 包含子路由 ====================
|
||
|
||
router.include_router(_upload_router)
|
||
router.include_router(_download_router)
|
||
router.include_router(viewers_router)
|
||
|
||
|
||
# ==================== 创建空白文件 ====================
|
||
|
||
@router.post(
|
||
path='/create',
|
||
summary='创建空白文件',
|
||
description='在指定目录下创建空白文件。',
|
||
)
|
||
async def create_empty_file(
|
||
session: SessionDep,
|
||
user: Annotated[User, Depends(auth_required)],
|
||
request: CreateFileRequest,
|
||
) -> ResponseBase:
|
||
"""创建空白文件端点"""
|
||
# 存储 user.id，避免后续 save() 导致 user 过期后无法访问
|
||
user_id = user.id
|
||
|
||
# 验证文件名
|
||
if not request.name or '/' in request.name or '\\' in request.name:
|
||
raise HTTPException(status_code=400, detail="无效的文件名")
|
||
|
||
# 验证父目录（排除已删除的）
|
||
parent = await Object.get(
|
||
session,
|
||
(Object.id == request.parent_id) & (Object.deleted_at == None)
|
||
)
|
||
if not parent or parent.owner_id != user_id:
|
||
raise HTTPException(status_code=404, detail="父目录不存在")
|
||
|
||
if not parent.is_folder:
|
||
raise HTTPException(status_code=400, detail="父对象不是目录")
|
||
|
||
if parent.is_banned:
|
||
http_exceptions.raise_banned("目标目录已被封禁，无法执行此操作")
|
||
|
||
# 检查是否已存在同名文件（仅检查未删除的）
|
||
existing = await Object.get(
|
||
session,
|
||
(Object.owner_id == user_id) &
|
||
(Object.parent_id == parent.id) &
|
||
(Object.name == request.name) &
|
||
(Object.deleted_at == None)
|
||
)
|
||
if existing:
|
||
raise HTTPException(status_code=409, detail="同名文件已存在")
|
||
|
||
# 确定存储策略
|
||
policy_id = request.policy_id or parent.policy_id
|
||
policy = await Policy.get(session, Policy.id == policy_id)
|
||
if not policy:
|
||
raise HTTPException(status_code=404, detail="存储策略不存在")
|
||
|
||
# 生成存储路径并创建空文件
|
||
storage_path: str | None = None
|
||
if policy.type == PolicyType.LOCAL:
|
||
storage_service = LocalStorageService(policy)
|
||
dir_path, storage_name, full_path = await storage_service.generate_file_path(
|
||
user_id=user_id,
|
||
original_filename=request.name,
|
||
)
|
||
await storage_service.create_empty_file(full_path)
|
||
storage_path = full_path
|
||
else:
|
||
raise HTTPException(status_code=501, detail="S3 存储暂未实现")
|
||
|
||
# 创建 PhysicalFile 记录
|
||
physical_file = PhysicalFile(
|
||
storage_path=storage_path,
|
||
size=0,
|
||
policy_id=policy_id,
|
||
reference_count=1,
|
||
)
|
||
physical_file = await physical_file.save(session)
|
||
|
||
# 创建 Object 记录
|
||
file_object = Object(
|
||
name=request.name,
|
||
type=ObjectType.FILE,
|
||
size=0,
|
||
physical_file_id=physical_file.id,
|
||
parent_id=request.parent_id,
|
||
owner_id=user_id,
|
||
policy_id=policy_id,
|
||
)
|
||
file_object = await file_object.save(session)
|
||
|
||
l.info(f"创建空白文件: {file_object.name}, id={file_object.id}")
|
||
|
||
return ResponseBase(data={
|
||
"id": str(file_object.id),
|
||
"name": file_object.name,
|
||
"size": file_object.size,
|
||
})
|
||
|
||
|
||
# ==================== WOPI 会话 ====================
|
||
|
||
@router.post(
|
||
path='/{file_id}/wopi-session',
|
||
summary='创建 WOPI 会话',
|
||
description='为 WOPI 类型的查看器创建编辑会话，返回编辑器 URL 和访问令牌。',
|
||
)
|
||
async def create_wopi_session(
|
||
session: SessionDep,
|
||
user: Annotated[User, Depends(auth_required)],
|
||
file_id: UUID,
|
||
) -> WopiSessionResponse:
|
||
"""
|
||
创建 WOPI 会话端点
|
||
|
||
流程：
|
||
1. 验证文件存在且属于当前用户
|
||
2. 查找文件扩展名对应的 WOPI 类型应用
|
||
3. 检查用户组权限
|
||
4. 生成 WOPI access token
|
||
5. 构建 editor URL
|
||
|
||
认证：JWT token 必填
|
||
|
||
错误处理：
|
||
- 404: 文件不存在 / 无可用 WOPI 应用
|
||
- 403: 用户组无权限
|
||
"""
|
||
# 验证文件
|
||
file_obj: Object | None = await Object.get(
|
||
session,
|
||
Object.id == file_id,
|
||
)
|
||
if not file_obj or file_obj.owner_id != user.id:
|
||
http_exceptions.raise_not_found("文件不存在")
|
||
|
||
if not file_obj.is_file:
|
||
http_exceptions.raise_bad_request("对象不是文件")
|
||
|
||
# 获取文件扩展名
|
||
name_parts = file_obj.name.rsplit('.', 1)
|
||
if len(name_parts) < 2:
|
||
http_exceptions.raise_bad_request("文件无扩展名，无法使用 WOPI 查看器")
|
||
ext = name_parts[1].lower()
|
||
|
||
# 查找 WOPI 类型的应用
|
||
from sqlalchemy import and_, select
|
||
ext_records: list[FileAppExtension] = await FileAppExtension.get(
|
||
session,
|
||
FileAppExtension.extension == ext,
|
||
fetch_mode="all",
|
||
load=FileAppExtension.app,
|
||
)
|
||
|
||
wopi_app: FileApp | None = None
|
||
for ext_record in ext_records:
|
||
app = ext_record.app
|
||
if app.type == FileAppType.WOPI and app.is_enabled:
|
||
# 检查用户组权限（FileAppGroupLink 是纯关联表，使用 session 查询）
|
||
if app.is_restricted:
|
||
stmt = select(FileAppGroupLink).where(
|
||
and_(
|
||
FileAppGroupLink.app_id == app.id,
|
||
FileAppGroupLink.group_id == user.group_id,
|
||
)
|
||
)
|
||
result = await session.exec(stmt)
|
||
if not result.first():
|
||
continue
|
||
wopi_app = app
|
||
break
|
||
|
||
if not wopi_app:
|
||
http_exceptions.raise_not_found("无可用的 WOPI 查看器")
|
||
|
||
if not wopi_app.wopi_editor_url_template:
|
||
http_exceptions.raise_bad_request("WOPI 应用未配置编辑器 URL 模板")
|
||
|
||
# 获取站点 URL
|
||
site_url_setting: Setting | None = await Setting.get(
|
||
session,
|
||
(Setting.type == SettingsType.BASIC) & (Setting.name == "siteURL"),
|
||
)
|
||
site_url = site_url_setting.value if site_url_setting else "http://localhost"
|
||
|
||
# 生成 WOPI token
|
||
can_write = file_obj.owner_id == user.id
|
||
token, access_token_ttl = create_wopi_token(file_id, user.id, can_write)
|
||
|
||
# 构建 wopi_src
|
||
wopi_src = f"{site_url}/wopi/files/{file_id}"
|
||
|
||
# 构建 editor URL
|
||
editor_url = wopi_app.wopi_editor_url_template.format(
|
||
wopi_src=wopi_src,
|
||
access_token=token,
|
||
access_token_ttl=access_token_ttl,
|
||
)
|
||
|
||
return WopiSessionResponse(
|
||
wopi_src=wopi_src,
|
||
access_token=token,
|
||
access_token_ttl=access_token_ttl,
|
||
editor_url=editor_url,
|
||
)
|
||
|
||
|
||
# ==================== 文件外链（保留原有端点结构） ====================
|
||
|
||
@router.get(
|
||
path='/get/{id}/{name}',
|
||
summary='文件外链（直接输出文件数据）',
|
||
description='通过外链直接获取文件内容。',
|
||
)
|
||
async def file_get(
|
||
session: SessionDep,
|
||
id: str,
|
||
name: str,
|
||
) -> FileResponse:
|
||
"""文件外链端点（直接输出）"""
|
||
raise HTTPException(status_code=501, detail="外链功能暂未实现")
|
||
|
||
|
||
@router.get(
|
||
path='/source/{id}/{name}',
|
||
summary='文件外链(301跳转)',
|
||
description='通过外链获取文件重定向地址。',
|
||
)
|
||
async def file_source_redirect(id: str, name: str) -> ResponseBase:
|
||
"""文件外链端点（301跳转）"""
|
||
raise HTTPException(status_code=501, detail="外链功能暂未实现")
|
||
|
||
|
||
@router.put(
|
||
path='/update/{id}',
|
||
summary='更新文件',
|
||
description='更新文件内容。',
|
||
dependencies=[Depends(auth_required)]
|
||
)
|
||
async def file_update(id: str) -> ResponseBase:
|
||
"""更新文件内容"""
|
||
raise HTTPException(status_code=501, detail="更新文件功能暂未实现")
|
||
|
||
|
||
@router.get(
|
||
path='/content/{file_id}',
|
||
summary='获取文本文件内容',
|
||
description='获取文本文件的 UTF-8 内容和 SHA-256 哈希值。',
|
||
)
|
||
async def file_content(
|
||
session: SessionDep,
|
||
user: Annotated[User, Depends(auth_required)],
|
||
file_id: UUID,
|
||
) -> TextContentResponse:
|
||
"""
|
||
获取文本文件内容端点
|
||
|
||
返回文件的 UTF-8 文本内容和基于规范化内容的 SHA-256 哈希值。
|
||
换行符统一规范化为 ``\\n``。
|
||
|
||
认证：JWT token 必填
|
||
|
||
错误处理：
|
||
- 400: 文件不是有效的 UTF-8 文本
|
||
- 404: 文件不存在
|
||
"""
|
||
file_obj = await Object.get(
|
||
session,
|
||
(Object.id == file_id) & (Object.deleted_at == None)
|
||
)
|
||
if not file_obj or file_obj.owner_id != user.id:
|
||
http_exceptions.raise_not_found("文件不存在")
|
||
|
||
if not file_obj.is_file:
|
||
http_exceptions.raise_bad_request("对象不是文件")
|
||
|
||
physical_file = await file_obj.awaitable_attrs.physical_file
|
||
if not physical_file or not physical_file.storage_path:
|
||
http_exceptions.raise_internal_error("文件存储路径丢失")
|
||
|
||
policy = await Policy.get(session, Policy.id == file_obj.policy_id)
|
||
if not policy:
|
||
http_exceptions.raise_internal_error("存储策略不存在")
|
||
|
||
if policy.type != PolicyType.LOCAL:
|
||
http_exceptions.raise_not_implemented("S3 存储暂未实现")
|
||
|
||
storage_service = LocalStorageService(policy)
|
||
raw_bytes = await storage_service.read_file(physical_file.storage_path)
|
||
|
||
try:
|
||
content = raw_bytes.decode('utf-8')
|
||
except UnicodeDecodeError:
|
||
http_exceptions.raise_bad_request("文件不是有效的 UTF-8 文本")
|
||
|
||
# 换行符规范化
|
||
content = content.replace('\r\n', '\n').replace('\r', '\n')
|
||
normalized_bytes = content.encode('utf-8')
|
||
hash_hex = hashlib.sha256(normalized_bytes).hexdigest()
|
||
|
||
return TextContentResponse(
|
||
content=content,
|
||
hash=hash_hex,
|
||
size=len(normalized_bytes),
|
||
)
|
||
|
||
|
||
@router.patch(
|
||
path='/content/{file_id}',
|
||
summary='增量保存文本文件',
|
||
description='使用 unified diff 增量更新文本文件内容。',
|
||
)
|
||
async def patch_file_content(
|
||
session: SessionDep,
|
||
user: Annotated[User, Depends(auth_required)],
|
||
file_id: UUID,
|
||
request: PatchContentRequest,
|
||
) -> PatchContentResponse:
|
||
"""
|
||
增量保存文本文件端点
|
||
|
||
接收 unified diff 和 base_hash，验证无并发冲突后应用 patch。
|
||
|
||
认证：JWT token 必填
|
||
|
||
错误处理：
|
||
- 400: 文件不是有效的 UTF-8 文本
|
||
- 404: 文件不存在
|
||
- 409: base_hash 不匹配（并发冲突）
|
||
- 422: 无效的 patch 格式或 patch 应用失败
|
||
"""
|
||
file_obj = await Object.get(
|
||
session,
|
||
(Object.id == file_id) & (Object.deleted_at == None)
|
||
)
|
||
if not file_obj or file_obj.owner_id != user.id:
|
||
http_exceptions.raise_not_found("文件不存在")
|
||
|
||
if not file_obj.is_file:
|
||
http_exceptions.raise_bad_request("对象不是文件")
|
||
|
||
if file_obj.is_banned:
|
||
http_exceptions.raise_banned()
|
||
|
||
physical_file = await file_obj.awaitable_attrs.physical_file
|
||
if not physical_file or not physical_file.storage_path:
|
||
http_exceptions.raise_internal_error("文件存储路径丢失")
|
||
|
||
storage_path = physical_file.storage_path
|
||
|
||
policy = await Policy.get(session, Policy.id == file_obj.policy_id)
|
||
if not policy:
|
||
http_exceptions.raise_internal_error("存储策略不存在")
|
||
|
||
if policy.type != PolicyType.LOCAL:
|
||
http_exceptions.raise_not_implemented("S3 存储暂未实现")
|
||
|
||
storage_service = LocalStorageService(policy)
|
||
raw_bytes = await storage_service.read_file(storage_path)
|
||
|
||
# 解码 + 规范化
|
||
original_text = raw_bytes.decode('utf-8')
|
||
original_text = original_text.replace('\r\n', '\n').replace('\r', '\n')
|
||
normalized_bytes = original_text.encode('utf-8')
|
||
|
||
# 冲突检测（hash 基于规范化后的内容，与 GET 端点一致）
|
||
current_hash = hashlib.sha256(normalized_bytes).hexdigest()
|
||
if current_hash != request.base_hash:
|
||
http_exceptions.raise_conflict("文件内容已被修改，请刷新后重试")
|
||
|
||
# 解析并应用 patch
|
||
diffs = list(whatthepatch.parse_patch(request.patch))
|
||
if not diffs:
|
||
http_exceptions.raise_unprocessable_entity("无效的 patch 格式")
|
||
|
||
try:
|
||
result = whatthepatch.apply_diff(diffs[0], original_text)
|
||
except HunkApplyException:
|
||
http_exceptions.raise_unprocessable_entity("Patch 应用失败，差异内容与当前文件不匹配")
|
||
|
||
new_text = '\n'.join(result)
|
||
|
||
# 保持尾部换行符一致
|
||
if original_text.endswith('\n') and not new_text.endswith('\n'):
|
||
new_text += '\n'
|
||
|
||
new_bytes = new_text.encode('utf-8')
|
||
|
||
# 写入文件
|
||
await storage_service.write_file(storage_path, new_bytes)
|
||
|
||
# 更新数据库
|
||
owner_id = file_obj.owner_id
|
||
old_size = file_obj.size
|
||
new_size = len(new_bytes)
|
||
size_diff = new_size - old_size
|
||
|
||
file_obj.size = new_size
|
||
file_obj = await file_obj.save(session, commit=False)
|
||
physical_file.size = new_size
|
||
physical_file = await physical_file.save(session, commit=False)
|
||
if size_diff != 0:
|
||
await adjust_user_storage(session, owner_id, size_diff, commit=False)
|
||
await session.commit()
|
||
|
||
new_hash = hashlib.sha256(new_bytes).hexdigest()
|
||
|
||
l.info(f"文本文件增量保存: file_id={file_id}, size={old_size}->{new_size}")
|
||
|
||
return PatchContentResponse(new_hash=new_hash, new_size=new_size)
|
||
|
||
|
||
@router.get(
|
||
path='/thumb/{id}',
|
||
summary='获取文件缩略图',
|
||
description='获取文件缩略图。',
|
||
dependencies=[Depends(auth_required)]
|
||
)
|
||
async def file_thumb(id: str) -> ResponseBase:
|
||
"""获取文件缩略图"""
|
||
raise HTTPException(status_code=501, detail="缩略图功能暂未实现")
|
||
|
||
|
||
@router.post(
|
||
path='/source/{id}',
|
||
summary='取得文件外链',
|
||
description='获取文件的外链地址。',
|
||
dependencies=[Depends(auth_required)]
|
||
)
|
||
async def file_source(id: str) -> ResponseBase:
|
||
"""获取文件外链"""
|
||
raise HTTPException(status_code=501, detail="外链功能暂未实现")
|
||
|
||
|
||
@router.post(
|
||
path='/archive',
|
||
summary='打包要下载的文件',
|
||
description='将多个文件打包下载。',
|
||
dependencies=[Depends(auth_required)]
|
||
)
|
||
async def file_archive() -> ResponseBase:
|
||
"""打包文件"""
|
||
raise HTTPException(status_code=501, detail="打包功能暂未实现")
|
||
|
||
|
||
@router.post(
|
||
path='/compress',
|
||
summary='创建文件压缩任务',
|
||
description='创建文件压缩任务。',
|
||
dependencies=[Depends(auth_required)]
|
||
)
|
||
async def file_compress() -> ResponseBase:
|
||
"""创建压缩任务"""
|
||
raise HTTPException(status_code=501, detail="压缩功能暂未实现")
|
||
|
||
|
||
@router.post(
|
||
path='/decompress',
|
||
summary='创建文件解压任务',
|
||
description='创建文件解压任务。',
|
||
dependencies=[Depends(auth_required)]
|
||
)
|
||
async def file_decompress() -> ResponseBase:
|
||
"""创建解压任务"""
|
||
raise HTTPException(status_code=501, detail="解压功能暂未实现")
|
||
|
||
|
||
@router.post(
|
||
path='/relocate',
|
||
summary='创建文件转移任务',
|
||
description='创建文件转移任务。',
|
||
dependencies=[Depends(auth_required)]
|
||
)
|
||
async def file_relocate() -> ResponseBase:
|
||
"""创建转移任务"""
|
||
raise HTTPException(status_code=501, detail="转移功能暂未实现")
|
||
|
||
|
||
@router.get(
|
||
path='/search/{type}/{keyword}',
|
||
summary='搜索文件',
|
||
description='按关键字搜索文件。',
|
||
dependencies=[Depends(auth_required)]
|
||
)
|
||
async def file_search(type: str, keyword: str) -> ResponseBase:
|
||
"""搜索文件"""
|
||
raise HTTPException(status_code=501, detail="搜索功能暂未实现")
|