feat: mint extract codes from data/local without re-upload

Admin can browse NAS files under data/local including subfolders and share
them in place. Shares use file_path=local-ref, skip storage quota, and never
delete the original file on expire.

Author: vastsa

apps/admin/services.py

@@ -1,28 +1,32 @@
 import asyncio
 import hashlib
-import io
 from pathlib import Path
-import os
-import time
-import uuid
 from datetime import datetime, timedelta
 from typing import Any, Optional
 
 from core.response import APIResponse
-from core.storage import FileStorageInterface, StoredFile, storages
+from core.storage import FileStorageInterface, storages
 from core.settings import (
     ADMIN_SESSION_EXPIRE_MAX,
     ADMIN_SESSION_EXPIRE_MIN,
     settings,
 )
 from apps.base.config import refresh_settings
-from apps.base.services import response_from_download, stored_file_of
+from apps.base.services import get_stored_download, response_from_download, stored_file_of
 from core.security import INTERNAL_CONFIG_KEYS, generate_jwt_secret
 from apps.base.models import FileCodes, KeyValue
-from apps.base.utils import get_expire_info, get_file_path_name
-from apps.base.quota import release_storage, reserve_storage
+from apps.base.utils import get_expire_info
+from apps.base.local_share import (
+    LOCAL_REF_MARKER,
+    MAX_LIST_ENTRIES,
+    format_local_ctime,
+    get_local_root,
+    is_local_ref,
+    normalize_local_relpath,
+    resolve_under_local,
+    should_skip_storage_delete,
+)
 from fastapi import HTTPException
-from core.settings import data_root
 from core.utils import get_now, hash_password, is_password_hashed, validate_background_url
 
 # KeyValue 里的 settings/activities/presets 都是整块 JSON 读-改-写；
@@ -98,7 +102,7 @@ def _file_metadata_key(self, file_id: int) -> str:
         return f"{self.FILE_METADATA_KEY_PREFIX}{file_id}"
 
     async def _delete_file_code(self, file_code: FileCodes):
-        if file_code.text is None:
+        if not should_skip_storage_delete(file_code):
             await self.file_storage.delete_file(stored_file_of(file_code))
         await KeyValue.filter(key=self._file_metadata_key(file_code.id)).delete()
         await file_code.delete()
@@ -498,7 +502,7 @@ async def list_files(
             "file_count": 0,
             "chunked_count": 0,
             **self._empty_health_summary(),
-            "storage_used": sum(file_code.size for file_code in all_files),
+            "storage_used": sum(file_code.size for file_code in all_files if not is_local_ref(file_code)),
             "used_count": sum(file_code.used_count for file_code in all_files),
         }
 
@@ -603,6 +607,7 @@ async def _build_admin_file_item(
             "file_hash": file_code.file_hash,
             "is_chunked": file_code.is_chunked,
             "upload_id": file_code.upload_id,
+            "is_local_ref": is_local_ref(file_code),
         }
         data.update(
             {
@@ -1412,7 +1417,7 @@ async def download_file(self, file_id: int):
         if file_code.text:
             return APIResponse(detail=file_code.text)
         else:
-            return response_from_download(await self.file_storage.get_file_response(stored_file_of(file_code)))
+            return response_from_download(await get_stored_download(file_code, self.file_storage))
 
     async def preview_file(self, file_id: int, max_chars: int = 4000):
         max_chars = min(max(max_chars, 1), 20000)
@@ -1443,40 +1448,28 @@ async def share_local_file(self, item):
         if not await local_file.exists():
             raise HTTPException(status_code=404, detail="文件不存在")
 
-        reservation_token = f"local:{uuid.uuid4().hex}"
-        await reserve_storage(reservation_token, local_file.size, ttl_seconds=3600)
-        try:
-            data = await local_file.read()  # bytes（read 内部用 with 关闭句柄）
-            expired_at, expired_count, used_count, code = await get_expire_info(
-                item.expire_value, item.expire_style
-            )
-            path, suffix, prefix, uuid_file_name, save_path = await get_file_path_name(
-                item
-            )
-            await self.file_storage.save_file(io.BytesIO(data), save_path)
-            try:
-                await FileCodes.create(
-                    code=code,
-                    prefix=prefix,
-                    suffix=suffix,
-                    uuid_file_name=uuid_file_name,
-                    file_path=path,
-                    size=local_file.size,
-                    expired_at=expired_at,
-                    expired_count=expired_count,
-                    used_count=used_count,
-                )
-            except Exception:
-                await self.file_storage.delete_file(
-                    StoredFile(file_path=path, uuid_file_name=uuid_file_name)
-                )
-                raise
-        finally:
-            await release_storage(reservation_token)
-
+        expired_at, expired_count, used_count, code = await get_expire_info(
+            item.expire_value, item.expire_style
+        )
+        name = local_file.name
+        suffix = Path(name).suffix
+        prefix = name[: len(name) - len(suffix)] if suffix else name
+        record = await FileCodes.create(
+            code=code,
+            prefix=prefix,
+            suffix=suffix,
+            uuid_file_name=local_file.file,
+            file_path=LOCAL_REF_MARKER,
+            size=local_file.size or 0,
+            expired_at=expired_at,
+            expired_count=expired_count,
+            used_count=used_count,
+        )
         return {
             "code": code,
-            "name": local_file.file,
+            "name": name,
+            "path": local_file.file,
+            "id": record.id,
         }
 
 
@@ -1587,18 +1580,55 @@ async def update_config(self, data: dict):
 
 
 class LocalFileService:
-    async def list_files(self):
-        files = []
-        if not os.path.exists(data_root / "local"):
-            os.makedirs(data_root / "local")
-        for file in os.listdir(data_root / "local"):
-            local_file = LocalFileClass(file)
-            files.append({
-                "file": local_file.file,
-                "ctime": local_file.ctime,
-                "size": local_file.size,
-            })
-        return files
+    async def list_files(self, path: str = ""):
+        relpath = normalize_local_relpath(path, allow_empty=True)
+        directory = resolve_under_local(relpath)
+        if not directory.exists() or not directory.is_dir():
+            raise HTTPException(status_code=404, detail="目录不存在")
+
+        root = get_local_root()
+        items = []
+        try:
+            children = list(directory.iterdir())
+        except OSError as exc:
+            raise HTTPException(status_code=500, detail="无法读取目录") from exc
+
+        children.sort(key=lambda p: (not p.is_dir(), p.name.lower()))
+        truncated = False
+        for child in children:
+            if len(items) >= MAX_LIST_ENTRIES:
+                truncated = True
+                break
+            try:
+                resolved = child.resolve()
+                resolved.relative_to(root)
+            except (OSError, ValueError):
+                continue
+            if not resolved.is_file() and not resolved.is_dir():
+                continue
+            child_rel = child.name if not relpath else f"{relpath}/{child.name}"
+            is_dir = resolved.is_dir()
+            items.append(
+                {
+                    "file": child.name,
+                    "name": child.name,
+                    "path": child_rel,
+                    "type": "dir" if is_dir else "file",
+                    "ctime": format_local_ctime(resolved),
+                    "size": None if is_dir else resolved.stat().st_size,
+                }
+            )
+
+        parent = ""
+        if relpath:
+            parent_path = Path(relpath).parent.as_posix()
+            parent = "" if parent_path == "." else parent_path
+        return {
+            "path": relpath,
+            "parent": parent,
+            "truncated": truncated,
+            "items": items,
+        }
 
     async def delete_file(self, filename: str):
         file = LocalFileClass(filename)
@@ -1610,39 +1640,13 @@ async def delete_file(self, filename: str):
 
 class LocalFileClass:
     def __init__(self, file):
-        # 仅允许 data/local 目录下的单层文件名，阻断路径穿越与绝对路径访问。
-        raw_name = str(file or "")
-        normalized = Path(raw_name).as_posix()
-        # 输入本身不得包含路径分隔符或绝对路径形态。
-        if (
-            not raw_name
-            or raw_name in {".", ".."}
-            or normalized in {".", ".."}
-            or "/" in normalized
-            or normalized.startswith("~")
-            or Path(raw_name).is_absolute()
-            or Path(raw_name).name != raw_name
-        ):
-            raise HTTPException(status_code=400, detail="非法文件名")
-
-        safe_name = Path(raw_name).name
-        if not safe_name or safe_name in {".", ".."}:
-            raise HTTPException(status_code=400, detail="非法文件名")
-
-        local_root = (data_root / "local").resolve()
-        candidate = (local_root / safe_name).resolve()
-        try:
-            candidate.relative_to(local_root)
-        except ValueError:
-            raise HTTPException(status_code=400, detail="非法文件路径")
-
-        self.file = safe_name
-        self.path = candidate
+        relpath = normalize_local_relpath(file)
+        self.file = relpath
+        self.name = Path(relpath).name
+        self.path = resolve_under_local(relpath)
         if self.path.is_file():
-            self.ctime = time.strftime(
-                "%Y-%m-%d %H:%M:%S", time.localtime(os.path.getctime(self.path))
-            )
-            self.size = os.path.getsize(self.path)
+            self.ctime = format_local_ctime(self.path)
+            self.size = self.path.stat().st_size
         else:
             self.ctime = None
             self.size = None
@@ -1652,11 +1656,13 @@ async def read(self) -> bytes:
             return fh.read()
 
     async def write(self, data):
-        with open(self.path, "w") as f:
+        with open(self.path, "wb") as f:
             f.write(data)
 
     async def delete(self):
-        os.remove(self.path)
+        if not self.path.is_file():
+            raise HTTPException(status_code=404, detail="文件不存在")
+        self.path.unlink()
 
     async def exists(self):
         return self.path.is_file()

apps/admin/views.py

@@ -31,6 +31,7 @@
 )
 from core.response import APIResponse
 from apps.base.models import FileCodes, KeyValue
+from apps.base.quota import owned_storage_queryset
 from tortoise.expressions import Q
 from tortoise.functions import Count, Sum
 from apps.admin.dependencies import (
@@ -144,7 +145,7 @@ async def dashboard(file_service: FileService = Depends(get_file_service)):
     # 健康摘要依赖逐行 rules engine（_build_file_status_insights），保留一次遍历。
     total_files = await FileCodes.all().count()
     expired_count = await FileCodes.filter(_expired_predicate(now)).count()
-    all_size = await _sum_size(FileCodes.all())
+    all_size = await _sum_size(owned_storage_queryset())
     used_count = (
         await FileCodes.all().annotate(total=Sum("used_count")).values("total")
     )[0]["total"] or 0
@@ -154,10 +155,14 @@ async def dashboard(file_service: FileService = Depends(get_file_service)):
         created_at__gte=yesterday_start, created_at__lte=yesterday_end
     ).count()
     yesterday_size = await _sum_size(
-        FileCodes.filter(created_at__gte=yesterday_start, created_at__lte=yesterday_end)
+        owned_storage_queryset(
+            FileCodes.filter(created_at__gte=yesterday_start, created_at__lte=yesterday_end)
+        )
     )
     today_count = await FileCodes.filter(created_at__gte=today_start).count()
-    today_size = await _sum_size(FileCodes.filter(created_at__gte=today_start))
+    today_size = await _sum_size(
+        owned_storage_queryset(FileCodes.filter(created_at__gte=today_start))
+    )
 
     suffix_rows = (
         await FileCodes.filter(text__isnull=True)
@@ -567,9 +572,10 @@ async def file_preview(
 
 @admin_api.get("/local/lists")
 async def get_local_lists(
+    path: str = "",
     local_file_service: LocalFileService = Depends(get_local_file_service),
 ):
-    files = await local_file_service.list_files()
+    files = await local_file_service.list_files(path)
     return APIResponse(detail=files)