# @Time : 2023/8/9 23:23 # @Author : Lan # @File : main.py # @Software: PyCharm import asyncio import html import time from contextlib import asynccontextmanager from urllib.parse import parse_qs from fastapi import FastAPI, HTTPException, Request from fastapi.middleware.cors import CORSMiddleware from fastapi.responses import FileResponse, HTMLResponse, JSONResponse, RedirectResponse from tortoise import Tortoise from tortoise.contrib.fastapi import register_tortoise from apps.admin.views import admin_api from apps.base.models import KeyValue from apps.base.utils import ip_limit from apps.base.views import share_api, chunk_api, presign_api from core.config import ( ensure_security_settings, ensure_settings_row, initialize_system, is_runtime_initialized, refresh_settings, ) from core.database import db_startup_lock, get_db_config, init_db from core.logger import logger from core.response import APIResponse from core.settings import settings, BASE_DIR, DEFAULT_CONFIG from core.tasks import delete_expire_files, clean_incomplete_uploads from core.version import APP_VERSION def build_public_config() -> dict: return { "name": settings.name, "description": settings.description, "explain": settings.page_explain, "uploadSize": settings.uploadSize, "allowedFileTypes": settings.allowed_file_types, "expireStyle": settings.expireStyle, "enableChunk": settings.enableChunk, "openUpload": settings.openUpload, "notify_title": settings.notify_title, "notify_content": settings.notify_content, "show_admin_address": settings.showAdminAddr, "max_save_seconds": settings.max_save_seconds, } def build_public_meta() -> dict: return { "version": APP_VERSION, "api": { "legacyConfig": "/", "publicConfig": "/api/v1/config", "health": "/health", }, "features": { "chunkUpload": bool(settings.enableChunk), "guestUpload": bool(settings.openUpload), "adminAddressVisible": bool(settings.showAdminAddr), "expirationModes": settings.expireStyle, }, "limits": { "uploadSize": settings.uploadSize, "allowedFileTypes": settings.allowed_file_types, "maxSaveSeconds": settings.max_save_seconds, "uploadWindowMinutes": settings.uploadMinute, "uploadWindowCount": settings.uploadCount, }, } FILE_SIZE_UNITS = {"KB": 1024, "MB": 1024**2, "GB": 1024**3} SAVE_TIME_UNITS = {"second": 1, "minute": 60, "hour": 3600, "day": 86400} EXPIRE_STYLE_OPTIONS = [ ("day", "按天"), ("hour", "按小时"), ("minute", "按分钟"), ("forever", "永久"), ("count", "按取件次数"), ] def get_form_value(data: dict, key: str, default: str = "") -> str: value = data.get(key, default) if isinstance(value, list): value = value[-1] if value else default return str(value if value is not None else default) def get_form_list(data: dict, key: str) -> list[str]: value = data.get(key, []) if isinstance(value, list): return [str(item) for item in value if str(item)] if value: return [str(value)] return [] def normalize_bool_field(data: dict, key: str, default: bool) -> bool: if key not in data: return default return get_form_value(data, key).lower() in {"1", "true", "on", "yes"} def parse_int_field( data: dict, key: str, default: int, label: str, min_value: int = 0, max_value: int | None = None, ) -> int: raw_value = get_form_value(data, key, str(default)).strip() try: value = int(raw_value) except ValueError: raise ValueError(f"{label} 必须是整数") if value < min_value: raise ValueError(f"{label} 不能小于 {min_value}") if max_value is not None and value > max_value: raise ValueError(f"{label} 不能大于 {max_value}") return value def parse_allowed_file_types(value: str) -> list[str]: items = [item.strip() for item in value.split(",") if item.strip()] return items or ["*"] def parse_setup_options(data: dict) -> dict: upload_size_unit = get_form_value(data, "upload_size_unit", "MB").upper() if upload_size_unit not in FILE_SIZE_UNITS: raise ValueError("文件大小单位不正确") upload_size_value = parse_int_field( data, "upload_size_value", 10, "文件大小限制", min_value=1 ) save_time_unit = get_form_value(data, "save_time_unit", "day") if save_time_unit not in SAVE_TIME_UNITS: raise ValueError("最长保存时间单位不正确") save_time_value = parse_int_field( data, "save_time_value", 0, "最长保存时间", min_value=0 ) expire_styles = get_form_list(data, "expireStyle") valid_expire_styles = {style for style, _label in EXPIRE_STYLE_OPTIONS} expire_styles = [style for style in expire_styles if style in valid_expire_styles] if not expire_styles: raise ValueError("至少需要选择一种过期方式") code_generate_type = get_form_value(data, "code_generate_type", "number") if code_generate_type not in {"number", "secret"}: raise ValueError("提取码类型不正确") return { "allowed_file_types": parse_allowed_file_types( get_form_value(data, "allowed_file_types", "*") ), "code_generate_type": code_generate_type, "enableChunk": int(normalize_bool_field(data, "enableChunk", False)), "errorCount": parse_int_field( data, "errorCount", DEFAULT_CONFIG["errorCount"], "取件错误次数限制", 1 ), "errorMinute": parse_int_field( data, "errorMinute", DEFAULT_CONFIG["errorMinute"], "取件错误检测窗口", 1 ), "expireStyle": expire_styles, "max_save_seconds": save_time_value * SAVE_TIME_UNITS[save_time_unit], "openUpload": int(normalize_bool_field(data, "openUpload", True)), "uploadCount": parse_int_field( data, "uploadCount", DEFAULT_CONFIG["uploadCount"], "上传次数限制", 1 ), "uploadMinute": parse_int_field( data, "uploadMinute", DEFAULT_CONFIG["uploadMinute"], "上传检测窗口", 1 ), "uploadSize": upload_size_value * FILE_SIZE_UNITS[upload_size_unit], } def build_expire_style_inputs(selected_styles: list[str]) -> str: inputs = [] selected = set(selected_styles) for style, label in EXPIRE_STYLE_OPTIONS: checked = " checked" if style in selected else "" inputs.append( f'' ) return "\n ".join(inputs) def build_setup_page(error: str = "", form: dict | None = None) -> str: form = form or {} escaped_error = html.escape(error) escaped_site_name = html.escape( get_form_value(form, "site_name", DEFAULT_CONFIG["name"]) ) escaped_allowed_types = html.escape(get_form_value(form, "allowed_file_types", "*")) upload_size_value = html.escape(get_form_value(form, "upload_size_value", "10")) upload_size_unit = get_form_value(form, "upload_size_unit", "MB").upper() save_time_value = html.escape(get_form_value(form, "save_time_value", "0")) save_time_unit = get_form_value(form, "save_time_unit", "day") upload_minute = html.escape( get_form_value(form, "uploadMinute", str(DEFAULT_CONFIG["uploadMinute"])) ) upload_count = html.escape( get_form_value(form, "uploadCount", str(DEFAULT_CONFIG["uploadCount"])) ) error_minute = html.escape( get_form_value(form, "errorMinute", str(DEFAULT_CONFIG["errorMinute"])) ) error_count = html.escape( get_form_value(form, "errorCount", str(DEFAULT_CONFIG["errorCount"])) ) open_upload_checked = ( " checked" if normalize_bool_field(form, "openUpload", True) else "" ) chunk_checked = ( " checked" if normalize_bool_field(form, "enableChunk", False) else "" ) code_generate_type = get_form_value(form, "code_generate_type", "number") selected_expire_styles = get_form_list(form, "expireStyle") or list( DEFAULT_CONFIG["expireStyle"] ) expire_style_inputs = build_expire_style_inputs(selected_expire_styles) size_unit_options = "\n".join( f'' for unit in FILE_SIZE_UNITS ) save_time_unit_options = "\n".join( f'' for unit, label in [ ("second", "秒"), ("minute", "分钟"), ("hour", "小时"), ("day", "天"), ] ) code_type_options = "\n".join( f'' for value, label in [("number", "数字"), ("secret", "随机字符")] ) error_block = ( f'' if escaped_error else "" ) return f""" 初始化 FileCodeBox
FCB

初始化 FileCodeBox

首次配置管理员密码、上传限制和取件策略,后续可在后台调整。

首次配置向导
{error_block}
基础设置
上传设置
取件与保存
可用策略
{expire_style_inputs}
""" def build_setup_success_page() -> str: return """ 初始化完成

初始化完成

管理员密码已设置,请使用刚才的密码登录后台。

进入后台
""" def setup_response(content: str, status_code: int = 200) -> HTMLResponse: return HTMLResponse( content=content, status_code=status_code, media_type="text/html", headers={"Cache-Control": "no-store"}, ) def is_setup_path(path: str) -> bool: return path.rstrip("/") == "/setup" def wants_html_response(request: Request) -> bool: if request.method not in {"GET", "HEAD"}: return False accept = request.headers.get("accept", "") return not accept or "text/html" in accept or "*/*" in accept async def read_setup_payload(request: Request) -> dict: content_type = request.headers.get("content-type", "") if "application/json" in content_type: data = await request.json() return data if isinstance(data, dict) else {} body = (await request.body()).decode("utf-8") return { key: values if len(values) > 1 else values[-1] for key, values in parse_qs(body).items() } @asynccontextmanager async def lifespan(app: FastAPI): logger.info("正在初始化应用...") # 初始化数据库 await init_db() # 加载配置(多进程下串行化启动写操作) async with db_startup_lock(): await load_config() # 启动后台任务 task = asyncio.create_task(delete_expire_files()) chunk_cleanup_task = asyncio.create_task(clean_incomplete_uploads()) logger.info("应用初始化完成") try: yield finally: # 清理操作 logger.info("正在关闭应用...") task.cancel() chunk_cleanup_task.cancel() await asyncio.gather(task, chunk_cleanup_task, return_exceptions=True) await Tortoise.close_connections() logger.info("应用已关闭") async def load_config(): await ensure_settings_row() await KeyValue.update_or_create( key="sys_start", defaults={"value": int(time.time() * 1000)} ) await refresh_settings() await ensure_security_settings() ip_limit["error"].minutes = settings.errorMinute ip_limit["error"].count = settings.errorCount ip_limit["upload"].minutes = settings.uploadMinute ip_limit["upload"].count = settings.uploadCount app = FastAPI(lifespan=lifespan) @app.middleware("http") async def refresh_settings_middleware(request, call_next): await refresh_settings() if not is_runtime_initialized() and not is_setup_path(request.url.path): if wants_html_response(request): return setup_response(build_setup_page()) return JSONResponse( status_code=428, content={ "code": 428, "message": "系统未初始化,请先完成初始化", "msg": "系统未初始化,请先完成初始化", "detail": {"setup": "/setup"}, }, ) return await call_next(request) app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) # 使用 register_tortoise 来添加异常处理器 register_tortoise( app, config=get_db_config(), generate_schemas=False, add_exception_handlers=True, ) app.include_router(share_api) app.include_router(chunk_api) app.include_router(presign_api) app.include_router(presign_api, prefix="/api") app.include_router(admin_api) @app.get("/setup", include_in_schema=False) @app.get("/setup/", include_in_schema=False) async def setup_page(): if is_runtime_initialized(): return RedirectResponse(url="/", status_code=303) return setup_response(build_setup_page()) @app.post("/setup", include_in_schema=False) @app.post("/setup/", include_in_schema=False) async def setup_submit(request: Request): if is_runtime_initialized(): return RedirectResponse(url="/", status_code=303) data = await read_setup_payload(request) admin_password = str(data.get("admin_password") or "") confirm_password = str(data.get("confirm_password") or "") site_name = str(data.get("site_name") or "") if admin_password != confirm_password: return setup_response(build_setup_page("两次输入的管理员密码不一致", data), 400) try: setup_options = parse_setup_options(data) await initialize_system( admin_password=admin_password, site_name=site_name, setup_options=setup_options, ) except ValueError as exc: return setup_response(build_setup_page(str(exc), data), 400) if "application/json" in request.headers.get("accept", ""): return APIResponse(detail={"ok": True, "admin": "/#/admin"}) return setup_response(build_setup_success_page()) def resolve_theme_root(): themes_root = (BASE_DIR / "themes").resolve() theme_root = (BASE_DIR / str(settings.themesSelect)).resolve() try: theme_root.relative_to(themes_root) except ValueError: theme_root = (BASE_DIR / DEFAULT_CONFIG["themesSelect"]).resolve() if not theme_root.exists(): theme_root = (BASE_DIR / DEFAULT_CONFIG["themesSelect"]).resolve() return theme_root def resolve_theme_file(*parts: str): theme_root = resolve_theme_root() file_path = theme_root.joinpath(*parts).resolve() # 防止通过 /assets/../ 读取主题目录外的文件。 try: file_path.relative_to(theme_root) except ValueError: raise HTTPException(status_code=404, detail="资源不存在") if not file_path.is_file(): raise HTTPException(status_code=404, detail="资源不存在") return file_path @app.get("/assets/{asset_path:path}", include_in_schema=False) async def theme_asset(asset_path: str): return FileResponse(resolve_theme_file("assets", asset_path)) @app.exception_handler(404) @app.get("/") async def index(request=None, exc=None): return HTMLResponse( content=resolve_theme_file("index.html") .read_text(encoding="utf-8") .replace("{{title}}", str(settings.name)) .replace("{{description}}", str(settings.description)) .replace("{{keywords}}", str(settings.keywords)) .replace("{{opacity}}", str(settings.opacity)) .replace("{{background}}", str(settings.background)), media_type="text/html", headers={"Cache-Control": "no-cache"}, ) @app.get("/robots.txt") async def robots(): return HTMLResponse(content=settings.robotsText, media_type="text/plain") @app.post("/") async def get_config(): return APIResponse(detail=build_public_config()) @app.get("/api/v1/config") async def get_public_config(): return APIResponse( detail={ "config": build_public_config(), "meta": build_public_meta(), } ) @app.get("/health") async def health_check(): return APIResponse( detail={ "status": "ok", "version": APP_VERSION, "storage": settings.file_storage, "theme": settings.themesSelect, } ) if __name__ == "__main__": import uvicorn uvicorn.run( app="main:app", host=settings.serverHost, port=settings.serverPort, reload=False, workers=settings.serverWorkers, )