import os from pathlib import Path from fastapi import UploadFile from app.config.setting import settings from app.core.base_schema import AuthSchema, DownloadFileSchema from app.core.exceptions import CustomException from app.core.logger import logger from app.utils.minio_util import MinioUtil from app.utils.upload_util import UploadUtil from .crud import FileCRUD from .schema import FileCreateSchema, FileOutSchema, FileQueryParam class FileService: """ 文件管理服务层 """ @classmethod async def upload_service( cls, auth: AuthSchema, base_url: str, file: UploadFile, upload_type: str = "file", target_path: str | None = None, business_type: str | None = None, business_id: int | None = None, ) -> FileOutSchema: """上传文件""" original_name = file.filename or "" content_type = file.content_type file_size = file.size or 0 filename, filepath, file_url = await UploadUtil.upload_file( file=file, base_url=base_url, upload_type=upload_type, target_path=target_path, ) storage_type = "local" bucket_name = None object_name = None final_file_url = f"{file_url}" final_file_path = f"{filepath}" if settings.MINIO_ENABLE: object_name = cls._build_object_name(upload_type=upload_type, filename=filename, filepath=filepath) try: final_file_url = MinioUtil.upload_file( object_name=object_name, file_path=filepath, content_type=content_type, ) except Exception: UploadUtil.delete_file(filepath) raise bucket_name = settings.MINIO_BUCKET_NAME storage_type = "minio" final_file_path = object_name UploadUtil.delete_file(filepath) try: file_record = await FileCRUD(auth).create( data=FileCreateSchema( storage_type=storage_type, bucket_name=bucket_name, object_name=object_name, original_name=original_name, file_name=filename, file_ext=UploadUtil.get_extension_from_filename(filename), content_type=content_type, file_size=file_size, file_path=final_file_path, file_url=final_file_url, upload_type=upload_type, business_type=business_type, business_id=business_id, ) ) except Exception: cls._delete_uploaded_object(storage_type=storage_type, bucket_name=bucket_name, object_name=object_name, file_path=final_file_path) raise return cls._to_out_schema(file_record) @classmethod async def page( cls, auth: AuthSchema, page_no: int, page_size: int, search: FileQueryParam | None = None, order_by: list[dict[str, str]] | None = None, ) -> dict: offset = (page_no - 1) * page_size page_result = await FileCRUD(auth).page( offset=offset, limit=page_size, order_by=order_by or [{"id": "desc"}], search=vars(search) if search else None, out_schema=FileOutSchema, ) for item in page_result.items: item["origin_name"] = item.get("original_name") return page_result @classmethod async def detail_service(cls, auth: AuthSchema, id: int) -> FileOutSchema: file_record = await FileCRUD(auth).get_or_404(id=id, msg="文件记录不存在") return cls._to_out_schema(file_record) @classmethod async def delete_service(cls, auth: AuthSchema, ids: list[int], delete_object: bool = False) -> None: if len(ids) < 1: raise CustomException(msg="删除失败，删除对象不能为空") records = await FileCRUD(auth).get_list(search={"id": ("in", ids)}) record_map = {record.id: record for record in records} for file_id in ids: if file_id not in record_map: raise CustomException(msg="删除失败，文件记录不存在") if delete_object: for record in records: cls._delete_storage_object(record) await FileCRUD(auth).delete(ids=ids) @classmethod def _to_out_schema(cls, file_record) -> FileOutSchema: result = FileOutSchema.model_validate(file_record) result.origin_name = result.original_name return result @classmethod def _build_object_name(cls, upload_type: str, filename: str, filepath: Path) -> str: try: relative_path = filepath.resolve().relative_to(settings.UPLOAD_FILE_PATH.resolve()) return relative_path.as_posix() except ValueError: return f"{upload_type}/{filename}" @classmethod def _delete_storage_object(cls, file_record) -> None: if file_record.storage_type == "minio" and file_record.object_name: MinioUtil.remove_object(object_name=file_record.object_name, bucket_name=file_record.bucket_name) return if file_record.file_path: UploadUtil.delete_file(Path(file_record.file_path)) @classmethod def _delete_uploaded_object(cls, storage_type: str, bucket_name: str | None, object_name: str | None, file_path: str | None) -> None: try: if storage_type == "minio" and object_name: MinioUtil.remove_object(object_name=object_name, bucket_name=bucket_name) return if file_path: UploadUtil.delete_file(Path(file_path)) except Exception as e: logger.error(f"清理上传文件失败: {e}") @classmethod def to_upload_response(cls, file_record: FileOutSchema): from app.core.base_schema import UploadResponseSchema return UploadResponseSchema( file_path=file_record.file_path, file_name=file_record.file_name, origin_name=file_record.original_name, file_url=file_record.file_url, ) @classmethod async def presigned_url_service(cls, auth: AuthSchema, id: int) -> str: file_record = await FileCRUD(auth).get_or_404(id=id, msg="文件记录不存在") if file_record.storage_type != "minio" or not file_record.object_name: if file_record.file_url: return file_record.file_url raise CustomException(msg="该文件不是MinIO文件，无法生成预签名地址") return MinioUtil.presigned_get_url(object_name=file_record.object_name, bucket_name=file_record.bucket_name) @classmethod async def download_service(cls, file_path: str) -> DownloadFileSchema: """下载文件""" if not file_path: raise CustomException(msg="请选择要下载的文件") dangerous_patterns = ["../", "..\\", "\0"] for pattern in dangerous_patterns: if pattern in file_path: logger.error(f"检测到路径穿越攻击: {file_path}") raise CustomException(msg="非法的文件路径") upload_root = settings.UPLOAD_FILE_PATH.resolve() abs_path = os.path.normpath(os.path.abspath(file_path)) if not abs_path.startswith(str(upload_root)): logger.error(f"路径不在上传目录内: {file_path}") raise CustomException(msg="非法的文件路径") if not UploadUtil.check_file_exists(abs_path): raise CustomException(msg="文件不存在") file_name = UploadUtil.download_file(abs_path) return DownloadFileSchema( file_path=abs_path, file_name=str(file_name), )