""" 文件系统操作相关 API """ from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Request from fastapi.responses import StreamingResponse, FileResponse from sqlalchemy.ext.asyncio import AsyncSession from sqlalchemy import select from typing import List import os import zipfile import io import mimetypes import json from pathlib import Path from urllib.parse import quote from app.core.database import get_db from app.core.deps import get_current_user, get_user_from_token_or_query from app.models.user import User from app.models.log import OperationLog from app.models.share import ShareLink from app.models.project import Project, ProjectMember from app.schemas.file import ( FileTreeNode, FileSaveRequest, FileOperateRequest, FileUploadResponse, ) from app.schemas.response import success_response from app.services.project_file_service import project_file_service from app.services.storage import storage_service from app.services.log_service import log_service from app.services.project_service import ( get_project_or_404, require_project_read_access, require_project_write_access, ) from app.core.enums import OperationType router = APIRouter() async def check_project_access( project_id: int, current_user: User, db: AsyncSession, require_write: bool = False ): """检查项目访问权限""" # 查询项目 result = await db.execute(select(Project).where(Project.id == project_id)) project = result.scalar_one_or_none() if not project: raise HTTPException(status_code=404, detail="项目不存在") # 检查是否是项目所有者 if project.owner_id == current_user.id: return project # 检查是否是项目成员 member_result = await db.execute( select(ProjectMember).where( ProjectMember.project_id == project_id, ProjectMember.user_id == current_user.id ) ) member = member_result.scalar_one_or_none() if not member: if project.is_public == 1 and not require_write: return project raise HTTPException(status_code=403, detail="无权访问该项目") # 如果需要写权限，检查成员角色 if require_write and member.role == "viewer": raise HTTPException(status_code=403, detail="无写入权限") return project def annotate_shared_files(tree: List[FileTreeNode], shared_paths: set[str]) -> None: """为文件树节点补充分享状态""" for node in tree: node.is_shared = bool(node.isLeaf and node.key in shared_paths) if node.children: annotate_shared_files(node.children, shared_paths) @router.get("/{project_id}/tree", response_model=dict) async def get_project_tree( project_id: int, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db) ): """获取项目目录树""" project, user_role = await require_project_read_access(db, project_id, current_user) # 获取项目根目录 project_root = storage_service.get_secure_path(project.storage_key) # 生成目录树 tree = storage_service.generate_tree(project_root) share_result = await db.execute( select(ShareLink.file_path).where( ShareLink.project_id == project_id, ShareLink.share_type == "file", ShareLink.status == 1, ) ) shared_paths = { file_path for file_path in share_result.scalars().all() if file_path } annotate_shared_files(tree, shared_paths) # 获取当前用户角色 user_role = "owner" # 默认是所有者 if project.owner_id != current_user.id: # 查询成员角色 member_result = await db.execute( select(ProjectMember).where( ProjectMember.project_id == project_id, ProjectMember.user_id == current_user.id ) ) member = member_result.scalar_one_or_none() if member: user_role = member.role return success_response(data={ "tree": tree, "user_role": user_role, "project_name": project.name, "project_description": project.description }) @router.get("/{project_id}/file", response_model=dict) async def get_file_content( project_id: int, path: str, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db) ): """获取文件内容""" project, _ = await require_project_read_access(db, project_id, current_user) # 获取文件路径 file_path = storage_service.get_secure_path(project.storage_key, path) # 读取文件内容 content = await storage_service.read_file(file_path) return success_response(data={"path": path, "content": content}) @router.post("/{project_id}/file", response_model=dict) async def save_file( project_id: int, file_data: FileSaveRequest, request: Request, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db) ): """保存文件内容""" project, _ = await require_project_write_access(db, project_id, current_user) message = await project_file_service.save_file( db, project_id, project, file_data.path, file_data.content, current_user, request=request, ) return success_response(message=message) @router.post("/{project_id}/file/operate", response_model=dict) async def operate_file( project_id: int, operation: FileOperateRequest, request: Request, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db) ): """文件操作（重命名、删除、创建目录、创建文件、移动）""" project, _ = await require_project_write_access(db, project_id, current_user) message = await project_file_service.operate_file( db, project_id, project, operation.action, operation.path, current_user, new_path=operation.new_path, content=operation.content, request=request, ) return success_response(message=message) @router.post("/{project_id}/upload", response_model=dict) async def upload_file( project_id: int, file: UploadFile = File(...), subfolder: str = "images", request: Request = None, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db) ): """上传文件（图片/附件）""" project, _ = await require_project_write_access(db, project_id, current_user) # 上传文件 file_info = await storage_service.upload_file( project.storage_key, file, subfolder=subfolder ) # 构建访问 URL file_info["url"] = f"/api/v1/files/{project_id}/assets/{subfolder}/{file_info['filename']}" # 记录日志 await log_service.log_file_operation( db=db, operation_type=OperationType.UPLOAD_IMAGE, project_id=project_id, file_path=f"_assets/{subfolder}/{file_info['filename']}", user=current_user, detail={ "original_filename": file.filename, "file_size": file_info.get("size", 0), }, request=request, ) return success_response(data=file_info, message="文件上传成功") @router.post("/{project_id}/upload-document", response_model=dict) async def upload_document( project_id: int, file: UploadFile = File(...), target_dir: str = "", request: Request = None, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db) ): """ 上传文档文件（PDF等）到项目目录 """ project, _ = await require_project_write_access(db, project_id, current_user) # 只允许PDF文件 allowed_extensions = [".pdf"] # 上传文件 file_info = await storage_service.upload_document( project.storage_key, file, target_dir=target_dir, allowed_extensions=allowed_extensions ) # 记录日志 await log_service.log_file_operation( db=db, operation_type=OperationType.UPLOAD_IMAGE, # 复用上传图片的日志类型 project_id=project_id, file_path=file_info['path'], user=current_user, detail={ "original_filename": file_info['original_filename'], "size": file_info['size'], "target_dir": target_dir }, request=request, ) return success_response(data=file_info, message="文档上传成功") @router.get("/{project_id}/document/{path:path}") async def get_document_file( project_id: int, path: str, request: Request, current_user: User = Depends(get_user_from_token_or_query), db: AsyncSession = Depends(get_db) ): """ 获取文档文件（PDF等）- 支持 HTTP Range 请求 """ import re import aiofiles project, _ = await require_project_read_access(db, project_id, current_user) # 获取文件路径 file_path = storage_service.get_secure_path(project.storage_key, path) if not file_path.exists() or not file_path.is_file(): raise HTTPException(status_code=404, detail="文件不存在") # 判断文件类型 content_type, _ = mimetypes.guess_type(str(file_path)) if not content_type: content_type = "application/octet-stream" # 获取文件大小 file_size = file_path.stat().st_size # 检查是否有 Range 请求头 range_header = request.headers.get("range") if range_header: # 解析 Range 头: bytes=start-end range_match = re.match(r"bytes=(\d+)-(\d*)", range_header) if range_match: start = int(range_match.group(1)) end = int(range_match.group(2)) if range_match.group(2) else file_size - 1 end = min(end, file_size - 1) # 读取指定范围的文件内容 async def file_iterator(): async with aiofiles.open(file_path, 'rb') as f: await f.seek(start) chunk_size = 1024 * 1024 # 1MB chunks remaining = end - start + 1 while remaining > 0: chunk = await f.read(min(chunk_size, remaining)) if not chunk: break remaining -= len(chunk) yield chunk headers = { "Content-Range": f"bytes {start}-{end}/{file_size}", "Accept-Ranges": "bytes", "Content-Length": str(end - start + 1), } return StreamingResponse( file_iterator(), status_code=206, # Partial Content headers=headers, media_type=content_type ) # 正常请求，返回完整文件（添加 Accept-Ranges 头） return FileResponse( path=str(file_path), media_type=content_type, filename=file_path.name, headers={"Accept-Ranges": "bytes"} ) @router.get("/{project_id}/assets/{subfolder}/{filename}") async def get_asset_file( project_id: int, subfolder: str, filename: str, db: AsyncSession = Depends(get_db) ): """获取资源文件（公开访问，支持分享）""" project = await get_project_or_404(db, project_id) # 获取文件路径 asset_path = f"_assets/{subfolder}/{filename}" file_path = storage_service.get_secure_path(project.storage_key, asset_path) if not file_path.exists() or not file_path.is_file(): raise HTTPException(status_code=404, detail="文件不存在") # 根据文件扩展名确定 MIME 类型 mime_type, _ = mimetypes.guess_type(filename) if mime_type is None: mime_type = "application/octet-stream" # 返回文件（流式响应） return FileResponse( path=file_path, filename=filename, media_type=mime_type ) @router.post("/{project_id}/import-documents", response_model=dict) async def import_documents( project_id: int, files: List[UploadFile] = File(...), target_path: str = "", request: Request = None, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db) ): """批量导入Markdown文档""" project, _ = await require_project_write_access(db, project_id, current_user) # 验证所有文件都是.md格式 for file in files: if not file.filename.endswith('.md'): raise HTTPException(status_code=400, detail=f"文件 {file.filename} 不是Markdown格式") # 获取目标目录路径 target_dir = storage_service.get_secure_path(project.storage_key, target_path) # 确保目标目录存在 if not target_dir.exists(): target_dir.mkdir(parents=True, exist_ok=True) # 保存所有文件 imported_files = [] for file in files: file_path = target_dir / file.filename content = await file.read() # 写入文件 with open(file_path, 'wb') as f: f.write(content) # 构建相对路径 relative_path = f"{target_path}/{file.filename}" if target_path else file.filename imported_files.append(relative_path) # 更新索引 try: text_content = content.decode('utf-8') file_title = Path(file.filename).stem await search_service.update_doc(project_id, relative_path, file_title, text_content) except Exception: pass # 记录日志 await log_service.log_file_operation( db=db, operation_type=OperationType.IMPORT_DOCUMENTS, project_id=project_id, file_path=target_path or "/", user=current_user, detail={ "file_count": len(imported_files), "files": imported_files, }, request=request, ) return success_response( data={"imported_files": imported_files}, message=f"成功导入 {len(imported_files)} 个文档" ) @router.get("/{project_id}/export-directory") async def export_directory( project_id: int, directory_path: str = "", request: Request = None, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db) ): """导出目录为ZIP包""" project, _ = await require_project_read_access(db, project_id, current_user) # 获取目标目录路径 source_dir = storage_service.get_secure_path(project.storage_key, directory_path) if not source_dir.exists() or not source_dir.is_dir(): raise HTTPException(status_code=404, detail="目录不存在") # 创建ZIP文件在内存中 zip_buffer = io.BytesIO() file_count = 0 with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file: # 遍历目录添加所有文件 for file_path in source_dir.rglob('*'): if file_path.is_file(): # 计算相对路径 arcname = file_path.relative_to(source_dir) zip_file.write(file_path, arcname) file_count += 1 # 重置buffer位置 zip_buffer.seek(0) # 生成ZIP文件名 safe_project_name = project.name.replace("/", "_").replace("\\", "_") zip_filename = ( f"{safe_project_name}.zip" if not directory_path else f"{safe_project_name}_{directory_path.replace('/', '_')}.zip" ) encoded_zip_filename = quote(zip_filename) # 记录日志 await log_service.log_file_operation( db=db, operation_type=OperationType.EXPORT_DOCUMENTS, project_id=project_id, file_path=directory_path or "/", user=current_user, detail={ "file_count": file_count, "zip_filename": zip_filename, }, request=request, ) return StreamingResponse( zip_buffer, media_type="application/zip", headers={ "Content-Disposition": f"attachment; filename*=UTF-8''{encoded_zip_filename}" } ) @router.get("/{project_id}/export-pdf") async def export_pdf( project_id: int, path: str, request: Request, current_user: User = Depends(get_user_from_token_or_query), db: AsyncSession = Depends(get_db) ): """已登录用户导出 Markdown 为 PDF""" import re from app.services.pdf_service import pdf_service project, _ = await require_project_read_access(db, project_id, current_user) file_path = storage_service.get_secure_path(project.storage_key, path) if not file_path.exists() or not file_path.is_file(): raise HTTPException(status_code=404, detail="文件不存在") content = await storage_service.read_file(file_path) filename = Path(path).stem + ".pdf" # 将 API 图片 URL 转为文件系统相对路径 content = re.sub(r'/api/v1/files/\d+/assets/', '_assets/', content) project_root = storage_service.get_secure_path(project.storage_key) try: pdf_buffer = await pdf_service.md_to_pdf(content, title=filename, base_url=str(project_root)) except RuntimeError as exc: raise HTTPException(status_code=503, detail=str(exc)) from exc encoded_filename = quote(filename) return StreamingResponse( pdf_buffer, media_type="application/pdf", headers={ "Content-Disposition": f"attachment; filename*=UTF-8''{encoded_filename}", "Content-Type": "application/pdf" } )