# @Time : 2023/8/14 14:38 # @Author : Lan # @File : views.py # @Software: PyCharm import datetime from collections import Counter from typing import Optional from fastapi import APIRouter, Depends, HTTPException from apps.admin.services import FileService, ConfigService, LocalFileService from apps.admin.dependencies import ( admin_required, get_admin_session, get_file_service, get_config_service, get_local_file_service, ) from apps.admin.schemas import ( IDData, IDsData, BatchUpdateFileData, BatchFilePolicyActionData, FilePolicyActionData, FileMetadataData, FileViewPresetData, FileViewPresetDeleteData, ShareItem, DeleteItem, LoginData, UpdateFileData, ) from core.response import APIResponse from apps.base.models import FileCodes, KeyValue, TransferStats from apps.admin.dependencies import create_token from core.settings import settings from core.utils import get_now, verify_password admin_api = APIRouter( prefix="/admin", tags=["管理"], dependencies=[Depends(admin_required)] ) def _pick_query_text(*values: Optional[str]) -> Optional[str]: for value in values: normalized_value = str(value or "").strip() if normalized_value: return normalized_value return None @admin_api.post("/login") async def login(data: LoginData): if not verify_password(data.password, settings.admin_token): raise HTTPException(status_code=401, detail="密码错误") token = create_token({"is_admin": True}) return APIResponse(detail={"token": token, "token_type": "Bearer"}) @admin_api.get("/verify") async def verify_admin(session: dict = Depends(get_admin_session)): return APIResponse(detail=session) @admin_api.post("/logout") async def logout_admin(): return APIResponse(detail={"ok": True}) async def build_dashboard_recent_file(file_code: FileCodes) -> dict: is_expired = await file_code.is_expired() return { "id": file_code.id, "code": file_code.code, "name": file_code.prefix + file_code.suffix, "suffix": file_code.suffix, "size": file_code.size, "text": file_code.text is not None, "expiredAt": file_code.expired_at, "expiredCount": file_code.expired_count, "usedCount": file_code.used_count, "createdAt": file_code.created_at, "isExpired": is_expired, } @admin_api.get("/dashboard") async def dashboard(file_service: FileService = Depends(get_file_service)): all_codes = await FileCodes.all() all_size = sum([code.size for code in all_codes]) sys_start = await KeyValue.filter(key="sys_start").first() now = await get_now() today_start = now.replace(hour=0, minute=0, second=0, microsecond=0) yesterday_start = today_start - datetime.timedelta(days=1) yesterday_end = today_start - datetime.timedelta(microseconds=1) yesterday_codes = FileCodes.filter( created_at__gte=yesterday_start, created_at__lte=yesterday_end ) today_codes = FileCodes.filter(created_at__gte=today_start) yesterday_file_codes = await yesterday_codes today_file_codes = await today_codes expired_count = 0 for file_code in all_codes: if await file_code.is_expired(): expired_count += 1 health_summary = await file_service.build_file_health_summary(all_codes, now=now) text_count = sum(1 for file_code in all_codes if file_code.text is not None) chunked_count = sum(1 for file_code in all_codes if file_code.is_chunked) used_count = sum([file_code.used_count for file_code in all_codes]) suffix_counter = Counter( "Text" if file_code.text is not None else (file_code.suffix or "file") for file_code in all_codes ) recent_file_codes = sorted( all_codes, key=lambda file_code: file_code.created_at.timestamp() if file_code.created_at else 0, reverse=True, )[:8] recent_activities = await file_service.list_admin_activities(limit=8) return APIResponse( detail={ "totalFiles": len(all_codes), "storageUsed": str(all_size), "sysUptime": sys_start.value if sys_start else None, "yesterdayCount": len(yesterday_file_codes), "yesterdaySize": str(sum([code.size for code in yesterday_file_codes])), "todayCount": len(today_file_codes), "todaySize": str(sum([code.size for code in today_file_codes])), "activeCount": len(all_codes) - expired_count, "expiredCount": expired_count, "textCount": text_count, "fileCount": len(all_codes) - text_count, "chunkedCount": chunked_count, "usedCount": used_count, "storageBackend": settings.file_storage, "uploadSizeLimit": settings.uploadSize, "openUpload": settings.openUpload, "enableChunk": settings.enableChunk, "maxSaveSeconds": settings.max_save_seconds, **health_summary, "healthSummary": health_summary, "topSuffixes": [ {"suffix": suffix, "count": count} for suffix, count in suffix_counter.most_common(8) ], "recentFiles": [ await build_dashboard_recent_file(file_code) for file_code in recent_file_codes ], "recentActivities": recent_activities["activities"], "recent_activities": recent_activities["activities"], } ) @admin_api.get("/activities") async def admin_activities( limit: int = 20, action: Optional[str] = None, targetType: Optional[str] = None, target_type: Optional[str] = None, keyword: Optional[str] = None, file_service: FileService = Depends(get_file_service), ): result = await file_service.list_admin_activities( limit=limit, action=action, target_type=_pick_query_text(targetType, target_type), keyword=keyword, ) return APIResponse(detail=result) @admin_api.get("/analytics") async def analytics(start: str = "", end: str = ""): now = await get_now() def parse_day(value: str, fallback: datetime.datetime) -> datetime.datetime: if not value: return fallback try: return datetime.datetime.strptime(value[:10], "%Y-%m-%d") except Exception: return fallback end_day = parse_day(end, now.replace(hour=0, minute=0, second=0, microsecond=0)) start_day = parse_day(start, end_day - datetime.timedelta(days=29)) end_exclusive = end_day + datetime.timedelta(days=1) raw_stats = await TransferStats.filter( created_at__gte=start_day, created_at__lt=end_exclusive, ).order_by("created_at", "id") stats = [] recent_downloads = {} for item in raw_stats: if item.action == "download": dedupe_key = ( item.file_code_id or item.code or "", item.ip or "", int(item.size or 0), ) previous = recent_downloads.get(dedupe_key) if previous and (item.created_at - previous).total_seconds() <= 5: continue recent_downloads[dedupe_key] = item.created_at stats.append(item) files = await FileCodes.all() file_map = {item.code: item for item in files} day_map = {} cursor = start_day while cursor < end_exclusive: key = cursor.strftime("%Y-%m-%d") day_map[key] = { "date": key, "downloads": 0, "uploads": 0, "downloadTraffic": 0, "uploadTraffic": 0, } cursor += datetime.timedelta(days=1) file_stats = {} for item in stats: key = item.created_at.strftime("%Y-%m-%d") row = day_map.get(key) if row and item.action == "download": row["downloads"] += 1 row["downloadTraffic"] += item.size or 0 elif row and item.action == "upload": row["uploads"] += 1 row["uploadTraffic"] += item.size or 0 if not item.code: continue bucket = file_stats.setdefault( item.code, { "downloads": 0, "downloadTraffic": 0, "uploads": 0, "uploadTraffic": 0, "name": item.name or item.code, "size": int(item.size or 0), "uploaded_at": None, "expired_at": item.expired_at, "deleted_at": None, "deleted": False, }, ) bucket["name"] = bucket["name"] or item.name or item.code bucket["size"] = bucket["size"] or int(item.size or 0) bucket["expired_at"] = bucket["expired_at"] or item.expired_at if item.action == "upload": bucket["uploads"] += 1 bucket["uploadTraffic"] += item.size or 0 bucket["uploaded_at"] = bucket["uploaded_at"] or item.created_at elif item.action == "download": bucket["downloads"] += 1 bucket["downloadTraffic"] += item.size or 0 elif item.action == "delete": bucket["deleted"] = True bucket["deleted_at"] = item.deleted_at or item.created_at for file_item in files: current_name = ( f"{file_item.prefix or ''}{file_item.suffix or ''}" or file_item.uuid_file_name or file_item.code ) bucket = file_stats.setdefault( file_item.code, { "downloads": 0, "downloadTraffic": 0, "uploads": 0, "uploadTraffic": 0, "name": current_name, "size": int(file_item.size or 0), "uploaded_at": file_item.created_at, "expired_at": file_item.expired_at, "deleted_at": None, "deleted": False, }, ) bucket["name"] = current_name bucket["size"] = int(file_item.size or 0) bucket["uploaded_at"] = file_item.created_at or bucket["uploaded_at"] bucket["expired_at"] = file_item.expired_at bucket["deleted"] = False bucket["deleted_at"] = None created_key = ( file_item.created_at.strftime("%Y-%m-%d") if file_item.created_at else "" ) created_row = day_map.get(created_key) if bucket["uploads"] <= 0: bucket["uploads"] = 1 bucket["uploadTraffic"] = int(file_item.size or 0) if created_row: created_row["uploads"] += 1 created_row["uploadTraffic"] += int(file_item.size or 0) missing_downloads = max(0, int(file_item.used_count or 0) - bucket["downloads"]) if missing_downloads: traffic = missing_downloads * int(file_item.size or 0) bucket["downloads"] += missing_downloads bucket["downloadTraffic"] += traffic if created_row: created_row["downloads"] += missing_downloads created_row["downloadTraffic"] += traffic def iso(value): return value.isoformat() if value else "" def current_file_expired(file_item) -> bool: if not file_item: return False if file_item.expired_at and file_item.expired_at < now: return True return file_item.expired_count == 0 def history_row(code: str, data: dict) -> dict: file_item = file_map.get(code) current_name = "" if file_item: current_name = ( f"{file_item.prefix or ''}{file_item.suffix or ''}" or file_item.uuid_file_name or file_item.code ) uploaded_at = file_item.created_at if file_item else data.get("uploaded_at") expired_at = file_item.expired_at if file_item else data.get("expired_at") size = int(file_item.size or 0) if file_item else data.get("size") or 0 return { "code": code, "name": current_name or data.get("name") or code, "size": str(size), "download_count": data.get("downloads") or 0, "download_traffic": str(data.get("downloadTraffic") or 0), "upload_count": data.get("uploads") or 0, "upload_traffic": str(data.get("uploadTraffic") or 0), "current": bool(file_item), "expired": current_file_expired(file_item), "deleted": bool(data.get("deleted")) and not bool(file_item), "created_at": iso(uploaded_at), "uploaded_at": iso(uploaded_at), "expired_at": iso(expired_at), "deleted_at": iso(data.get("deleted_at")), } def sort_time(value) -> float: return value.timestamp() if value else 0 history = sorted( file_stats.items(), key=lambda kv: ( sort_time(kv[1].get("deleted_at") or kv[1].get("uploaded_at")), kv[1].get("downloads") or 0, kv[1].get("downloadTraffic") or 0, ), reverse=True, ) top_files = sorted( [item for item in history if (item[1].get("downloads") or 0) > 0], key=lambda kv: (kv[1].get("downloads") or 0, kv[1].get("downloadTraffic") or 0), reverse=True, )[:5] daily_rows = list(day_map.values()) return APIResponse( detail={ "range": { "start": start_day.strftime("%Y-%m-%d"), "end": end_day.strftime("%Y-%m-%d"), }, "totals": { "totalDownloads": sum(row["downloads"] for row in daily_rows), "downloadedFiles": len( [item for item in file_stats.values() if (item.get("downloads") or 0) > 0] ), "downloadTraffic": str( sum(row["downloadTraffic"] for row in daily_rows) ), "historicalFiles": len(file_stats), "currentFiles": len(files), "totalUploads": sum(row["uploads"] for row in daily_rows), "uploadTraffic": str( sum(row["uploadTraffic"] for row in daily_rows) ), }, "daily": daily_rows, "topFiles": [history_row(code, data) for code, data in top_files], "historyFiles": [history_row(code, data) for code, data in history], } ) @admin_api.delete("/file/delete") async def file_delete( data: IDData, file_service: FileService = Depends(get_file_service), ): await file_service.delete_file(data.id) return APIResponse() async def batch_delete_files( data: IDsData, file_service: FileService, ): if not data.ids: raise HTTPException(status_code=400, detail="请选择要删除的文件") result = await file_service.delete_files(data.ids) return APIResponse(detail=result) @admin_api.delete("/file/batch-delete") async def file_batch_delete( data: IDsData, file_service: FileService = Depends(get_file_service), ): return await batch_delete_files(data, file_service) @admin_api.post("/file/batch-delete") async def file_batch_delete_post( data: IDsData, file_service: FileService = Depends(get_file_service), ): return await batch_delete_files(data, file_service) async def batch_update_files( data: BatchUpdateFileData, file_service: FileService, ): if not data.ids: raise HTTPException(status_code=400, detail="请选择要更新的文件") update_data = {} fields_set = data.model_fields_set should_clear_expired_at = bool(data.clearExpiredAt or data.clear_expired_at) if should_clear_expired_at: update_data["expired_at"] = None update_data["expired_count"] = -1 elif "expired_at" in fields_set and data.expired_at != "": update_data["expired_at"] = data.expired_at if ( not should_clear_expired_at and "expired_count" in fields_set and data.expired_count is not None ): update_data["expired_count"] = data.expired_count if not update_data: raise HTTPException(status_code=400, detail="请选择要更新的字段") result = await file_service.update_files(data.ids, update_data) return APIResponse(detail=result) @admin_api.patch("/file/batch-update") async def file_batch_update( data: BatchUpdateFileData, file_service: FileService = Depends(get_file_service), ): return await batch_update_files(data, file_service) @admin_api.post("/file/batch-update") async def file_batch_update_post( data: BatchUpdateFileData, file_service: FileService = Depends(get_file_service), ): return await batch_update_files(data, file_service) async def apply_file_policy_action( data: FilePolicyActionData, file_service: FileService, ): download_limit = data.downloadLimit if download_limit is None: download_limit = data.download_limit detail = await file_service.apply_file_policy_action( file_id=data.id, action=data.action, download_limit=download_limit, ) return APIResponse(detail=detail) @admin_api.patch("/file/policy-action") async def file_policy_action( data: FilePolicyActionData, file_service: FileService = Depends(get_file_service), ): return await apply_file_policy_action(data, file_service) @admin_api.post("/file/policy-action") async def file_policy_action_post( data: FilePolicyActionData, file_service: FileService = Depends(get_file_service), ): return await apply_file_policy_action(data, file_service) async def apply_batch_file_policy_action( data: BatchFilePolicyActionData, file_service: FileService, ): if not data.ids: raise HTTPException(status_code=400, detail="请选择要更新的文件") download_limit = data.downloadLimit if download_limit is None: download_limit = data.download_limit result = await file_service.apply_files_policy_action( file_ids=data.ids, action=data.action, download_limit=download_limit, ) return APIResponse(detail=result) @admin_api.patch("/file/batch-policy-action") async def file_batch_policy_action( data: BatchFilePolicyActionData, file_service: FileService = Depends(get_file_service), ): return await apply_batch_file_policy_action(data, file_service) @admin_api.post("/file/batch-policy-action") async def file_batch_policy_action_post( data: BatchFilePolicyActionData, file_service: FileService = Depends(get_file_service), ): return await apply_batch_file_policy_action(data, file_service) @admin_api.get("/file/list") async def file_list( page: int = 1, size: int = 10, keyword: str = "", status: str = "", type: str = "", health: str = "", sortBy: str = "created_at", sortOrder: str = "desc", file_service: FileService = Depends(get_file_service), ): page = max(page, 1) size = min(max(size, 1), 100) files, total, summary = await file_service.list_files( page, size, keyword, status=status, file_type=type, health=health, sort_by=sortBy, sort_order=sortOrder, ) return APIResponse( detail={ "page": page, "size": size, "data": files, "total": total, "summary": summary, } ) @admin_api.get("/file/detail") async def file_detail( id: int, file_service: FileService = Depends(get_file_service), ): detail = await file_service.get_file_detail(id) return APIResponse(detail=detail) @admin_api.post("/file/detail") async def file_detail_post( data: IDData, file_service: FileService = Depends(get_file_service), ): detail = await file_service.get_file_detail(data.id) return APIResponse(detail=detail) async def update_file_metadata( data: FileMetadataData, file_service: FileService, ): fields_set = data.model_fields_set update_note = "note" in fields_set update_tags = "tags" in fields_set if not update_note and not update_tags: raise HTTPException(status_code=400, detail="请选择要更新的元数据") detail = await file_service.update_file_metadata( file_id=data.id, note=data.note, tags=data.tags, update_note=update_note, update_tags=update_tags, ) return APIResponse(detail=detail) @admin_api.patch("/file/metadata") async def file_metadata( data: FileMetadataData, file_service: FileService = Depends(get_file_service), ): return await update_file_metadata(data, file_service) @admin_api.post("/file/metadata") async def file_metadata_post( data: FileMetadataData, file_service: FileService = Depends(get_file_service), ): return await update_file_metadata(data, file_service) @admin_api.get("/file/view-presets") async def file_view_presets( file_service: FileService = Depends(get_file_service), ): result = await file_service.list_file_view_presets() return APIResponse(detail=result) async def save_file_view_preset( data: FileViewPresetData, file_service: FileService, ): filters = data.filters if data.filters is not None else data.params preset = await file_service.save_file_view_preset( preset_id=data.id, name=data.name, filters=filters or {}, ) return APIResponse(detail=preset) @admin_api.post("/file/view-presets") async def file_view_presets_save( data: FileViewPresetData, file_service: FileService = Depends(get_file_service), ): return await save_file_view_preset(data, file_service) @admin_api.patch("/file/view-presets") async def file_view_presets_patch( data: FileViewPresetData, file_service: FileService = Depends(get_file_service), ): return await save_file_view_preset(data, file_service) async def delete_file_view_preset( data: FileViewPresetDeleteData, file_service: FileService, ): result = await file_service.delete_file_view_preset(data.id) return APIResponse(detail=result) @admin_api.delete("/file/view-presets") async def file_view_presets_delete( data: FileViewPresetDeleteData, file_service: FileService = Depends(get_file_service), ): return await delete_file_view_preset(data, file_service) @admin_api.post("/file/view-presets/delete") async def file_view_presets_delete_post( data: FileViewPresetDeleteData, file_service: FileService = Depends(get_file_service), ): return await delete_file_view_preset(data, file_service) @admin_api.get("/config/get") async def get_config( config_service: ConfigService = Depends(get_config_service), ): return APIResponse(detail=config_service.get_config()) @admin_api.patch("/config/update") async def update_config( data: dict, config_service: ConfigService = Depends(get_config_service), file_service: FileService = Depends(get_file_service), ): data.pop("themesChoices", None) await config_service.update_config(data) await file_service.record_admin_activity( action="config.update", target_type="config", target_name="system", count=1, meta={"fields": sorted(data.keys())}, ) return APIResponse() @admin_api.get("/file/download") async def file_download( id: int, file_service: FileService = Depends(get_file_service), ): file_content = await file_service.download_file(id) return file_content @admin_api.get("/file/preview") async def file_preview( id: int, maxChars: int = 4000, file_service: FileService = Depends(get_file_service), ): preview = await file_service.preview_file(id, maxChars) return APIResponse(detail=preview) @admin_api.get("/local/lists") async def get_local_lists( local_file_service: LocalFileService = Depends(get_local_file_service), ): files = await local_file_service.list_files() return APIResponse(detail=files) @admin_api.delete("/local/delete") async def delete_local_file( item: DeleteItem, local_file_service: LocalFileService = Depends(get_local_file_service), file_service: FileService = Depends(get_file_service), ): result = await local_file_service.delete_file(item.filename) await file_service.record_admin_activity( action="local_file.delete", target_type="local_file", target_name=item.filename, count=1, meta={"success": bool(result)}, ) return APIResponse(detail=result) @admin_api.post("/local/share") async def share_local_file( item: ShareItem, file_service: FileService = Depends(get_file_service), ): share_info = await file_service.share_local_file(item) await file_service.record_admin_activity( action="local_file.share", target_type="file", target_id=share_info.get("id") if isinstance(share_info, dict) else None, target_name=item.filename, count=1, meta={ "expireValue": item.expire_value, "expireStyle": item.expire_style, }, ) return APIResponse(detail=share_info) @admin_api.patch("/file/update") async def update_file( data: UpdateFileData, file_service: FileService = Depends(get_file_service), ): file_code = await FileCodes.filter(id=data.id).first() if not file_code: raise HTTPException(status_code=404, detail="文件不存在") target_name = file_service._build_file_activity_name(file_code) update_data = {} if data.code is not None and data.code != file_code.code: # 判断code是否存在 if await FileCodes.filter(code=data.code).first(): raise HTTPException(status_code=400, detail="code已存在") update_data["code"] = data.code if data.prefix is not None and data.prefix != file_code.prefix: update_data["prefix"] = data.prefix if data.suffix is not None and data.suffix != file_code.suffix: update_data["suffix"] = data.suffix if ( data.expired_at is not None and data.expired_at != "" and data.expired_at != file_code.expired_at ): update_data["expired_at"] = data.expired_at if data.expired_count is not None and data.expired_count != file_code.expired_count: update_data["expired_count"] = data.expired_count await file_code.update_from_dict(update_data).save() if update_data: await file_service.record_admin_activity( action="file.update", target_type="file", target_id=data.id, target_name=target_name, count=1, meta={"fields": sorted(update_data.keys())}, ) return APIResponse(detail="更新成功")