Files
Marrrrrrrrry 57c75a7141 全量修复/补测试+UED改进 (#535)
* fix: constant-time comparison for download tokens (security item 5)

Replace the set-membership key check in /share/download with
hmac.compare_digest over the two valid window tokens; add negative-path
tests (wrong key 403, both windows accepted, foreign-code token 403).

* fix: single source for attachment headers + guard tests (security item 2)

All six Content-Disposition construction sites across the five storage
backends now go through build_attachment_headers; the header is what
neutralizes stored XSS on the same-origin download path. Guard tests
assert every get_file_response uses the builder and no hand-built
disposition reappears.

* fix: reject internal-network endpoints for storage config (security item 7)

s3_endpoint_url/s3_hostname/webdav_url are fetched server-side; with
APP_ENV=production the write entry now enforces http(s) schemes and a
loopback/private/link-local/metadata host blacklist. Development env
stays open for local minio/webdav. Already-stored values are never
re-validated, so existing deployments are unaffected.

* fix: JSON 404 for handler-raised 404s; negative-path test batch

Starlette status-code handlers take precedence over the HTTPException
class handler, so registering the theme index as the 404 handler turned
every HTTPException(404) app-wide into a 200 HTML page (found by the new
negative-path tests). The new not_found_handler serves the theme page
only to browsers (Accept: text/html) and JSON 404 to API clients.

Negative-path batch: download count exhaustion, missing chunk session
404s, expired presign session deletion, admin update_file uniqueness/
existence.

* fix: run container as non-root app user with compat volume chown (security item 3)

Entrypoint starts as root only to fix the data-dir ownership (skipped
when nothing needs changing or when the deployer sets an explicit user),
then drops to uid 10001 via gosu. Verified in-container: uvicorn runs as
app (uid 10001), setup and share round-trip work against a root-owned
volume.

* fix: compare download tokens as bytes (non-ASCII key caused 500)

* test: lock changed-only semantics for endpoint config saves

Integration regression for the background lesson: a stored internal
endpoint must not block unrelated settings saves in production mode;
changing to an internal endpoint (URL or bare-hostname form) is 400.

* fix: resolve-based SSRF check — deny IP shorthands, hex/decimal IPs, DNS maps

Probe found the static blacklist bypassed by glibc shorthands (127.1,
10.1), decimal (2130706433) and hex IP forms, *.localhost, and
loopback-mapping DNS services. Both validators now resolve the host and
re-check every resolved address; hostname tier extracts the host part
correctly for [v6]/host:port/bare-v6 forms. 44 tests.

* test: pin 404 handler dual-branch behavior (browser theme page vs API JSON)

* fix: write back normalized endpoint values; hostname dev-gate test

* test: header-injection negative paths for attachment disposition

* fix: S3 merge buffers parts to >=5MiB; missing object 404 upfront

- S3 multipart rejects parts <5MiB (EntityTooSmall) except the last; chunk
  size is client-controlled (commonly 2-4MB) so multi-chunk merges always
  failed with 500. Merge now buffers chunks into >=5MiB parts (memory
  bound: 5MB + one chunk).
- get_file_response: a 404 head_object now raises StorageError(404)
  upfront instead of signing a doomed presigned URL and failing mid-stream
  (aligns with local backend semantics from the M2 behavior unification).

* test: S3 backend coverage via in-process moto server (13 cases)

mock_aws cannot intercept aioboto3's aiohttp stack, so tests run against
a real in-process ThreadedMotoServer endpoint. Covers roundtrips, missing
object 404, merge failure modes (missing chunk / hash mismatch -> abort,
no leftover object), cleanup scoping, presign shapes, proxy dispatch.
Also adds moto[s3,server] to the dev group and CI.

* fix: WebDAV missing object 404 upfront; connection errors map to 503

HEAD 404 was silently swallowed (signed a 200 bad stream that failed
mid-download, same family as the S3 bug), and HEAD connection errors were
also swallowed so the 503 mapping never fired. Both now surface properly;
the aiohttp session is reclaimed on pre-stream exception paths.

* test: WebDAV backend coverage via in-process WebDAV server (9 cases)

Real HTTP (HEAD/GET/PUT/DELETE/MKCOL/PROPFIND) against a minimal aiohttp
WebDAV server over a temp dir: roundtrips, missing object 404, connection
error 503, delete with empty-parent cleanup, merge failure modes, chunk
cleanup scoping.

* fix: OneDrive missing object maps to 404 upfront; OpenDAL behavior pinned

OneDrive get_file_response translated graph itemNotFound into the outer
503 catch-all; now raises StorageError(404) like local/S3/WebDAV.
OpenDAL already mapped missing objects to 404 via its outer catch —
pinned with fake-operator tests (SDK not in runtime deps, instances built
via __new__). Also tightens the S3 presign URL assertion.

* test: admin write-path coverage (batch/single delete, batch update, policy actions)

13 negative-path cases for the previously untested data-modifying admin
endpoints: mixed-id aggregation with duplicates and missing records,
empty-list rejections, clear_expired_at permanence semantics, policy
action boundaries (zero limit 400, unknown action 400, missing 404),
and the DoesNotExist->404 mapping pinned for single delete.

* test: admin read-path and view-preset CRUD coverage (22 cases)

Detail/metadata/preview/admin-download/activities/local-lists+delete/
verify: missing-record 404s, note/tag truncation limits, preview max_chars
truncation, activity filtering and the 80-event clamp, local path
traversal rejection. Presets: update-vs-create by id, name truncation,
filter normalization clamps, 24-preset cap, delete-missing 404.

* refactor: move auth primitives to apps/base/auth, kill base->admin dep

JWT create/verify, bearer extraction and the share-upload gate move to
apps.base.auth (consumed by both surfaces); admin.dependencies keeps
admin session gating and service providers, re-exporting the primitives
for import-path compatibility. base.views no longer imports from
apps.admin — the last cross-app reverse dependency is gone.

* refactor: split admin services god-module (ConfigService/LocalFile out)

apps/admin/services.py (1697 lines) becomes FileService (~1200 lines) +
a compatibility facade re-exporting ConfigService, LocalFileService,
LocalFileClass and keyvalue_write_lock from their new homes
(config_service.py holds the D5 KeyValue lock; one-way imports, no
cycle). test_admin_security patch targets follow ConfigService to its
new module. Behavior unchanged; 247 tests green.

* fix: size-less uploads no longer crash (upstream seek bug)

validate_file_size's size-None branch called UploadFile.seek(0, 2),
which raises TypeError (UploadFile.seek takes one arg); the underlying
SpooledTemporaryFile.seek is sync, so awaiting it also fails. Use the
underlying file object with sync seek(0, SEEK_END). Surface discovered
by the mypy pilot run; regression test covers the size-None branch.

* chore: bump direct deps (patch/minor)

fastapi 0.139.2->0.141.1, pydantic 2.12.5->2.13.5, uvicorn 0.51.0->0.53.0,
aiohttp 3.14.2->3.14.3; lockfile regenerated. tortoise-orm 0.x->1.x major
deliberately deferred pending API-change review.

* ci: gradual mypy adoption via baseline ratchet

scripts/mypy_ratchet.py compares mypy output against
scripts/mypy-baseline.txt (line numbers stripped for edit stability):
new type errors fail CI, fixes are folded back via --regenerate.
Baseline starts at 30 known errors; the seek bug found in the pilot was
fixed before baselining. mypy joins the dev group and CI.

* fix: migrate WebDAV auth off aiohttp.BasicAuth (deprecated in 4.0)

Dependency-upgrade probe on aiohttp 3.14.3 surfaced the BasicAuth
deprecation; switch to aiohttp.encode_basic_auth() headers so the
aiohttp 4.0 upgrade does not break the WebDAV backend.

* chore: drop dead code (WebDAV _instance stub, unused LocalFileClass.write)

* test: file-validation negative paths (13 cases)

Magic-bytes spoofing (text-as-png, exe-as-pdf, mp4/webp box detection),
whitelist rule semantics (star/image-wildcard/content mismatch), chunk-0
header validation parity, and end-to-end UploadFile rejection.

* test: migration runner coverage (5 cases)

Full chain executes 001-007 in filename order and registers; rerun is
idempotent; pre-registered entries are skipped (DDL not re-executed);
the resulting schema matches deployment; a failing migration propagates
and is not registered. Uses a fresh :memory: DB without
generate_schemas so the migrations themselves build the schema (the
real deployment path).

* refactor: split core/storage.py into a package (per-backend modules)

core/storage.py (1400+ lines, six backends) becomes core/storage/ with
_base.py (data contracts, interface, shared header builder), and
local/s3/onedrive/opendal/webdav modules. The package __init__
re-exports the full historical public surface; test patch targets move
to the precise backend modules (core.storage.local.data_root etc.) and
the attachment guard scans the package. Import-only change; 264 tests
green. Storage-layer DI deferred: current tests construct instances
against patched settings, so the added surface isn't justified yet.

* refactor: TypedDict for IPRateLimit records

The rate-limit ledger mixed int and datetime under a loose Union typing,
producing 5 mypy noise errors. A TypedDict gives precise per-key types;
setdefault replaces the get-then-assign pattern. One mypy baseline error
family resolved; 264 tests green.

* chore: tighten mypy baseline after IPRateLimit TypedDict

* refactor: resolve all 26 baseline mypy errors; precise test assertions

Per-error treatment (no bulk script): honest annotations for
StoredDownload (Path/bytes/Callable), KeyValue.value (Any for JSONField),
dict[str, Any] for form/config dicts; signature split in create_token;
str() normalization in config int(); platform/type-ignore only where the
checker cannot follow (msvcrt, FastAPI Request injection). Baseline file
and ratchet compare now redundant at zero errors but kept as the guard
against regressions.

Tests: assertions tightened to status_code == 403 with HTTPException
raises; _create_share explicit parameters replace **extra passthrough;
seek-fix pointer-reset assertion persisted.
2026-09-20 03:01:08 +09:00

1466 lines
53 KiB
Python

import hashlib
from pathlib import Path
from datetime import datetime, timedelta
from typing import Any, Optional
from core.response import APIResponse
from core.storage import FileStorageInterface, storages
from core.settings import (
settings,
)
from apps.base.services import get_stored_download, response_from_download, stored_file_of
from apps.base.models import FileCodes, KeyValue
from apps.base.utils import get_expire_info
from apps.base.local_share import (
LOCAL_REF_MARKER,
is_local_ref,
should_skip_storage_delete,
)
from fastapi import HTTPException
from core.utils import get_now
class FileService:
FILE_METADATA_KEY_PREFIX = "admin_file_metadata:"
FILE_VIEW_PRESETS_KEY = "admin_file_view_presets"
ADMIN_ACTIVITY_KEY = "admin_activity_events"
MAX_METADATA_NOTE_LENGTH = 2000
MAX_METADATA_TAGS = 12
MAX_METADATA_TAG_LENGTH = 24
MAX_VIEW_PRESETS = 24
MAX_VIEW_PRESET_NAME_LENGTH = 32
MAX_VIEW_PRESET_KEYWORD_LENGTH = 80
MAX_ADMIN_ACTIVITIES = 80
MAX_ADMIN_ACTIVITY_TEXT_LENGTH = 120
POLICY_ACTIONS = {
"extend_24h",
"extend_7d",
"make_permanent",
"reset_download_limit",
}
SORT_FIELDS = {
"created_at",
"createdat",
"expired_at",
"expiredat",
"name",
"size",
"used_count",
"usedcount",
"code",
}
VIEW_PRESET_STATUS_VALUES = {"all", "active", "expired"}
VIEW_PRESET_TYPE_VALUES = {"all", "file", "text", "chunked"}
VIEW_PRESET_HEALTH_VALUES = {
"all",
"attention",
"danger",
"warning",
"healthy",
"expired",
"expiring_soon",
"storage_issue",
"never_retrieved",
"permanent",
}
VIEW_PRESET_SORT_FIELDS = {
"created_at",
"expired_at",
"name",
"size",
"used_count",
"code",
}
def __init__(self):
self._file_storage: Optional[FileStorageInterface] = None
@property
def file_storage(self) -> FileStorageInterface:
if self._file_storage is None:
self._file_storage = storages[settings.file_storage]()
return self._file_storage
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 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()
async def delete_file(self, file_id: int):
file_code = await FileCodes.get(id=file_id)
target_name = self._build_file_activity_name(file_code)
await self._delete_file_code(file_code)
await self.record_admin_activity(
action="file.delete",
target_type="file",
target_id=file_id,
target_name=target_name,
count=1,
)
async def delete_files(self, file_ids: list[int]):
unique_ids = list(dict.fromkeys(file_ids))
deleted = []
failed = []
missing = []
for file_id in unique_ids:
file_code = await FileCodes.filter(id=file_id).first()
if not file_code:
missing.append(file_id)
continue
try:
await self._delete_file_code(file_code)
deleted.append(file_id)
except Exception as exc:
failed.append({"id": file_id, "reason": str(exc)})
if deleted:
await self.record_admin_activity(
action="files.batch_delete",
target_type="file",
count=len(deleted),
meta={
"requested_count": len(file_ids),
"unique_count": len(unique_ids),
"deleted": deleted,
"missing": missing,
"failed_count": len(failed),
},
)
return {
"requested_count": len(file_ids),
"unique_count": len(unique_ids),
"deleted_count": len(deleted),
"missing_count": len(missing),
"failed_count": len(failed),
"deleted": deleted,
"missing": missing,
"failed": failed,
}
async def update_files(self, file_ids: list[int], update_data: dict[str, Any]):
unique_ids = list(dict.fromkeys(file_ids))
updated = []
failed = []
missing = []
for file_id in unique_ids:
file_code = await FileCodes.filter(id=file_id).first()
if not file_code:
missing.append(file_id)
continue
try:
await file_code.update_from_dict(update_data).save()
updated.append(file_id)
except Exception as exc:
failed.append({"id": file_id, "reason": str(exc)})
if updated:
await self.record_admin_activity(
action="files.batch_update",
target_type="file",
count=len(updated),
meta={
"fields": sorted(update_data.keys()),
"requested_count": len(file_ids),
"unique_count": len(unique_ids),
"updated": updated,
"missing": missing,
"failed_count": len(failed),
},
)
return {
"requested_count": len(file_ids),
"unique_count": len(unique_ids),
"updated_count": len(updated),
"missing_count": len(missing),
"failed_count": len(failed),
"updated": updated,
"missing": missing,
"failed": failed,
}
async def update_file(
self,
file_id: int,
code: Optional[str] = None,
prefix: Optional[str] = None,
suffix: Optional[str] = None,
expired_at: Optional[Any] = None,
expired_count: Optional[int] = None,
) -> dict[str, Any]:
file_code = await FileCodes.filter(id=file_id).first()
if not file_code:
raise HTTPException(status_code=404, detail="文件不存在")
update_data: dict[str, Any] = {}
if code is not None and code != file_code.code:
if await FileCodes.filter(code=code).first():
raise HTTPException(status_code=400, detail="code已存在")
update_data["code"] = code
if prefix is not None and prefix != file_code.prefix:
update_data["prefix"] = prefix
if suffix is not None and suffix != file_code.suffix:
update_data["suffix"] = suffix
if expired_at is not None and expired_at != "" and expired_at != file_code.expired_at:
update_data["expired_at"] = expired_at
if expired_count is not None and expired_count != file_code.expired_count:
update_data["expired_count"] = expired_count
if update_data:
target_name = self._build_file_activity_name(file_code)
await file_code.update_from_dict(update_data).save()
await self.record_admin_activity(
action="file.update",
target_type="file",
target_id=file_id,
target_name=target_name,
count=1,
meta={"fields": sorted(update_data.keys())},
)
return {"updated": bool(update_data), "fields": sorted(update_data.keys())}
async def apply_file_policy_action(
self,
file_id: int,
action: str,
download_limit: Optional[int] = None,
) -> dict[str, Any]:
file_code = await FileCodes.filter(id=file_id).first()
if not file_code:
raise HTTPException(status_code=404, detail="文件不存在")
action = action.strip().lower()
now = await get_now()
update_data = self._build_policy_action_update(
file_code=file_code,
action=action,
now=now,
download_limit=download_limit,
)
await file_code.update_from_dict(update_data).save()
await self.record_admin_activity(
action="file.policy_action",
target_type="file",
target_id=file_id,
target_name=self._build_file_activity_name(file_code),
count=1,
meta={"policy_action": action},
)
return await self.get_file_detail(file_id)
async def get_file_metadata(self, file_id: int) -> dict[str, Any]:
record = await KeyValue.filter(key=self._file_metadata_key(file_id)).first()
return self._normalize_file_metadata(record.value if record else None)
async def update_file_metadata(
self,
file_id: int,
note: Optional[str],
tags: Optional[list[str]],
update_note: bool,
update_tags: bool,
) -> dict[str, Any]:
file_code = await FileCodes.filter(id=file_id).first()
if not file_code:
raise HTTPException(status_code=404, detail="文件不存在")
current_metadata = await self.get_file_metadata(file_id)
next_metadata = dict(current_metadata)
if update_note:
next_metadata["note"] = self._normalize_metadata_note(note)
if update_tags:
next_metadata["tags"] = self._normalize_metadata_tags(tags)
now = await get_now()
updated_at = now.isoformat()
next_metadata["updated_at"] = updated_at
await KeyValue.update_or_create(
key=self._file_metadata_key(file_id),
defaults={"value": next_metadata},
)
await self.record_admin_activity(
action="file.metadata_update",
target_type="file",
target_id=file_id,
target_name=self._build_file_activity_name(file_code),
count=1,
meta={
"update_note": update_note,
"update_tags": update_tags,
"tag_count": len(next_metadata["tags"]),
},
)
return await self.get_file_detail(file_id)
async def list_file_view_presets(self) -> dict[str, Any]:
presets = await self._get_file_view_presets()
return {
"presets": presets,
"total": len(presets),
}
async def save_file_view_preset(
self,
preset_id: Optional[str],
name: str,
filters: dict[str, Any],
) -> dict[str, Any]:
async with keyvalue_write_lock:
presets = await self._get_file_view_presets()
normalized_name = self._normalize_file_view_preset_name(name)
normalized_filters = self._normalize_file_view_preset_filters(filters)
now = await get_now()
updated_at = now.isoformat()
target_index = next(
(index for index, preset in enumerate(presets) if preset["id"] == preset_id),
-1,
)
is_update = target_index >= 0
if is_update:
preset = presets[target_index]
next_preset = {
**preset,
"name": normalized_name,
"filters": normalized_filters,
"updated_at": updated_at,
}
presets[target_index] = next_preset
else:
if len(presets) >= self.MAX_VIEW_PRESETS:
raise HTTPException(status_code=400, detail="视图预设数量已达上限")
next_preset = {
"id": preset_id or self._build_file_view_preset_id(normalized_name, now),
"name": normalized_name,
"filters": normalized_filters,
"created_at": updated_at,
"updated_at": updated_at,
}
presets.append(next_preset)
await self._save_file_view_presets(presets)
await self.record_admin_activity(
action="file.view_preset_update" if is_update else "file.view_preset_create",
target_type="view_preset",
target_id=next_preset["id"],
target_name=next_preset["name"],
count=1,
meta={"filters": normalized_filters},
)
return next_preset
async def delete_file_view_preset(self, preset_id: str) -> dict[str, Any]:
preset_id = str(preset_id).strip()
if not preset_id:
raise HTTPException(status_code=400, detail="请选择要删除的视图预设")
async with keyvalue_write_lock:
presets = await self._get_file_view_presets()
deleted_preset = next(
(preset for preset in presets if preset["id"] == preset_id),
None,
)
next_presets = [preset for preset in presets if preset["id"] != preset_id]
if len(next_presets) == len(presets):
raise HTTPException(status_code=404, detail="视图预设不存在")
await self._save_file_view_presets(next_presets)
await self.record_admin_activity(
action="file.view_preset_delete",
target_type="view_preset",
target_id=preset_id,
target_name=(deleted_preset or {}).get("name", ""),
count=1,
)
return {
"deleted_preset_id": preset_id,
"total": len(next_presets),
}
async def apply_files_policy_action(
self,
file_ids: list[int],
action: str,
download_limit: Optional[int] = None,
) -> dict[str, Any]:
unique_ids = list(dict.fromkeys(file_ids))
updated = []
failed = []
missing = []
action = action.strip().lower()
if action not in self.POLICY_ACTIONS:
raise HTTPException(status_code=400, detail="不支持的策略动作")
if action == "reset_download_limit":
next_limit = download_limit if download_limit is not None else 5
if next_limit < 1:
raise HTTPException(status_code=400, detail="取件次数必须大于 0")
now = await get_now()
for file_id in unique_ids:
file_code = await FileCodes.filter(id=file_id).first()
if not file_code:
missing.append(file_id)
continue
try:
update_data = self._build_policy_action_update(
file_code=file_code,
action=action,
now=now,
download_limit=download_limit,
)
await file_code.update_from_dict(update_data).save()
updated.append(file_id)
except Exception as exc:
failed.append({"id": file_id, "reason": str(exc)})
if updated:
await self.record_admin_activity(
action="files.batch_policy_action",
target_type="file",
count=len(updated),
meta={
"policy_action": action,
"requested_count": len(file_ids),
"unique_count": len(unique_ids),
"updated": updated,
"missing": missing,
"failed_count": len(failed),
},
)
return {
"requested_count": len(file_ids),
"unique_count": len(unique_ids),
"updated_count": len(updated),
"missing_count": len(missing),
"failed_count": len(failed),
"action": action,
"updated": updated,
"missing": missing,
"failed": failed,
}
async def list_files(
self,
page: int,
size: int,
keyword: str = "",
status: str = "",
file_type: str = "",
health: str = "",
sort_by: str = "created_at",
sort_order: str = "desc",
):
page = max(page, 1)
size = min(max(size, 1), 100)
keyword = keyword.strip().lower()
status = status.strip().lower()
file_type = file_type.strip().lower()
health = health.strip().lower()
sort_by = self._normalize_sort_by(sort_by)
reverse = sort_order.strip().lower() != "asc"
all_files = await FileCodes.all()
now = await get_now()
enriched_files = []
summary = {
"total_files": len(all_files),
"active_count": 0,
"expired_count": 0,
"text_count": 0,
"file_count": 0,
"chunked_count": 0,
**self._empty_health_summary(),
"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),
}
for file_code in all_files:
item = await self._build_admin_file_item(file_code, now=now)
if item["is_expired"]:
summary["expired_count"] += 1
else:
summary["active_count"] += 1
if item["is_text"]:
summary["text_count"] += 1
else:
summary["file_count"] += 1
if item["is_chunked"]:
summary["chunked_count"] += 1
self._accumulate_health_summary(summary, item)
if not self._match_admin_file(item, keyword, status, file_type, health):
continue
enriched_files.append(item)
enriched_files.sort(
key=lambda item: self._get_sort_value(item, sort_by),
reverse=reverse,
)
offset = (page - 1) * size
return enriched_files[offset : offset + size], len(enriched_files), summary
def _empty_health_summary(self) -> dict[str, int]:
return {
"health_attention_count": 0,
"health_danger_count": 0,
"health_warning_count": 0,
"expiring_soon_count": 0,
"storage_issue_count": 0,
"never_retrieved_count": 0,
"healthy_count": 0,
"permanent_count": 0,
}
def _accumulate_health_summary(self, summary: dict[str, Any], item: dict[str, Any]) -> None:
status_insights = item.get("status_insights") or {}
reasons = status_insights.get("reasons") or []
severity = status_insights.get("severity")
state = status_insights.get("state")
if severity in {"danger", "warning"}:
summary["health_attention_count"] += 1
if severity == "danger":
summary["health_danger_count"] += 1
if severity == "warning":
summary["health_warning_count"] += 1
if severity == "success":
summary["healthy_count"] += 1
if state == "permanent":
summary["permanent_count"] += 1
if "expires_soon" in reasons:
summary["expiring_soon_count"] += 1
if "storage_metadata_incomplete" in reasons:
summary["storage_issue_count"] += 1
if "never_retrieved" in reasons:
summary["never_retrieved_count"] += 1
async def build_file_health_summary(
self, file_codes: list[FileCodes], now: Optional[datetime] = None
) -> dict[str, int]:
if now is None:
now = await get_now()
summary = self._empty_health_summary()
for file_code in file_codes:
item = await self._build_admin_file_item(file_code, now=now)
self._accumulate_health_summary(summary, item)
return summary
async def _build_admin_file_item(
self, file_code: FileCodes, now: Optional[datetime] = None
) -> dict[str, Any]:
if now is None:
now = await get_now()
is_text = file_code.text is not None
is_expired = await file_code.is_expired()
name = f"{file_code.prefix}{file_code.suffix}"
has_download_limit = file_code.expired_count >= 0
is_permanent = file_code.expired_at is None and file_code.expired_count < 0
can_download = is_text or bool(file_code.file_path or file_code.uuid_file_name)
remaining_downloads = (
max(file_code.expired_count, 0) if file_code.expired_count >= 0 else None
)
data = {
"id": file_code.id,
"code": file_code.code,
"prefix": file_code.prefix,
"suffix": file_code.suffix,
"uuid_file_name": file_code.uuid_file_name,
"file_path": file_code.file_path,
"size": file_code.size or 0,
"text": file_code.text,
"expired_at": file_code.expired_at,
"expired_count": file_code.expired_count,
"used_count": file_code.used_count,
"created_at": file_code.created_at,
"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(
{
"name": name,
"type": "text" if is_text else "file",
"status": "expired" if is_expired else "active",
"is_text": is_text,
"is_expired": is_expired,
"is_chunked": file_code.is_chunked,
"remaining_downloads": remaining_downloads,
"used_count": file_code.used_count,
"created_at": file_code.created_at,
"expired_at": file_code.expired_at,
"file_hash": file_code.file_hash,
}
)
status_insights = self._build_file_status_insights(
file_code=file_code,
detail=data,
now=now,
has_download_limit=has_download_limit,
is_permanent=is_permanent,
can_download=can_download,
)
data.update(
{
"status_insights": status_insights,
}
)
return data
async def get_file_detail(self, file_id: int):
file_code = await FileCodes.filter(id=file_id).first()
if not file_code:
raise HTTPException(status_code=404, detail="文件不存在")
now = await get_now()
detail = await self._build_admin_file_item(file_code, now=now)
is_text = file_code.text is not None
has_download_limit = file_code.expired_count >= 0
is_permanent = file_code.expired_at is None and file_code.expired_count < 0
text_length = len(file_code.text) if file_code.text else 0
can_download = is_text or bool(file_code.file_path or file_code.uuid_file_name)
status_insights = self._build_file_status_insights(
file_code=file_code,
detail=detail,
now=now,
has_download_limit=has_download_limit,
is_permanent=is_permanent,
can_download=can_download,
)
timeline = self._build_file_timeline(
file_code=file_code,
detail=detail,
now=now,
has_download_limit=has_download_limit,
is_permanent=is_permanent,
is_text=is_text,
)
detail.update(
{
"filename": detail["name"],
"display_name": detail["name"],
"is_permanent": is_permanent,
"has_download_limit": has_download_limit,
"has_expiration_time": file_code.expired_at is not None,
"text_length": text_length,
"can_preview_text": is_text,
"can_download": can_download,
"storage_backend": settings.file_storage,
"file_path": file_code.file_path,
"uuid_file_name": file_code.uuid_file_name,
"upload_id": file_code.upload_id,
"policy": {
"expired_at": file_code.expired_at,
"expired_count": file_code.expired_count,
"remaining_downloads": detail["remaining_downloads"],
"is_expired": detail["is_expired"],
"is_permanent": is_permanent,
},
"storage": {
"backend": settings.file_storage,
"file_path": file_code.file_path,
"uuid_file_name": file_code.uuid_file_name,
"file_hash": file_code.file_hash,
"is_chunked": file_code.is_chunked,
"upload_id": file_code.upload_id,
},
"status_insights": status_insights,
"timeline": timeline,
}
)
metadata = await self.get_file_metadata(file_id)
detail.update(
{
"metadata": metadata,
"note": metadata["note"],
"tags": metadata["tags"],
"metadata_updated_at": metadata["updated_at"],
}
)
return detail
def _normalize_metadata_note(self, note: Optional[str]) -> str:
if note is None:
return ""
return str(note).strip()[: self.MAX_METADATA_NOTE_LENGTH]
def _normalize_metadata_tags(self, tags: Any) -> list[str]:
if not tags:
return []
if isinstance(tags, str):
tags = [tags]
elif not isinstance(tags, list):
return []
normalized_tags = []
seen_tags = set()
for raw_tag in tags:
tag = str(raw_tag).strip()
if not tag:
continue
tag = tag[: self.MAX_METADATA_TAG_LENGTH]
dedupe_key = tag.lower()
if dedupe_key in seen_tags:
continue
seen_tags.add(dedupe_key)
normalized_tags.append(tag)
if len(normalized_tags) >= self.MAX_METADATA_TAGS:
break
return normalized_tags
def _normalize_file_metadata(self, metadata: Any) -> dict[str, Any]:
if not isinstance(metadata, dict):
metadata = {}
updated_at = metadata.get("updated_at") or metadata.get("updatedAt")
return {
"note": self._normalize_metadata_note(metadata.get("note")),
"tags": self._normalize_metadata_tags(metadata.get("tags")),
"updated_at": updated_at,
}
async def list_admin_activities(
self,
limit: int = 8,
action: Optional[str] = None,
target_type: Optional[str] = None,
keyword: Optional[str] = None,
) -> dict[str, Any]:
try:
normalized_limit = int(limit or 8)
except (TypeError, ValueError):
normalized_limit = 8
limit = min(max(normalized_limit, 1), self.MAX_ADMIN_ACTIVITIES)
activities = await self._get_admin_activities()
normalized_action = self._normalize_admin_activity_text(action).lower()
normalized_target_type = self._normalize_admin_activity_text(target_type).lower()
normalized_keyword = self._normalize_admin_activity_text(keyword).lower()
filtered_activities = self._filter_admin_activities(
activities,
action=normalized_action,
target_type=normalized_target_type,
keyword=normalized_keyword,
)
visible_activities = filtered_activities[:limit]
action_options = self._build_admin_activity_options(activities, "action")
target_type_options = self._build_admin_activity_options(activities, "target_type")
return {
"activities": visible_activities,
"total": len(filtered_activities),
"stored_total": len(activities),
"limit": limit,
"filters": {
"action": normalized_action,
"target_type": normalized_target_type,
"keyword": normalized_keyword,
},
"action_options": action_options,
"target_type_options": target_type_options,
}
async def record_admin_activity(
self,
action: str,
target_type: str,
target_id: Optional[Any] = None,
target_name: str = "",
count: int = 1,
meta: Optional[dict[str, Any]] = None,
) -> Optional[dict[str, Any]]:
try:
now = await get_now()
created_at = now.isoformat()
activity = self._normalize_admin_activity(
{
"id": self._build_admin_activity_id(
action=action,
target_type=target_type,
target_id=target_id,
target_name=target_name,
timestamp=now,
),
"action": action,
"target_type": target_type,
"target_id": target_id,
"target_name": target_name,
"count": count,
"meta": meta or {},
"created_at": created_at,
}
)
if not activity:
return None
async with keyvalue_write_lock:
activities = await self._get_admin_activities()
next_activities = [
activity,
*[item for item in activities if item["id"] != activity["id"]],
][: self.MAX_ADMIN_ACTIVITIES]
await self._save_admin_activities(next_activities)
return activity
except Exception:
return None
async def _get_admin_activities(self) -> list[dict[str, Any]]:
record = await KeyValue.filter(key=self.ADMIN_ACTIVITY_KEY).first()
raw_activities = record.value if record else []
if isinstance(raw_activities, dict):
raw_activities = (
raw_activities.get("activities") or raw_activities.get("items") or []
)
if not isinstance(raw_activities, list):
return []
activities = []
seen_ids = set()
for raw_activity in raw_activities:
activity = self._normalize_admin_activity(raw_activity)
if not activity or activity["id"] in seen_ids:
continue
seen_ids.add(activity["id"])
activities.append(activity)
if len(activities) >= self.MAX_ADMIN_ACTIVITIES:
break
activities.sort(key=lambda item: item.get("created_at") or "", reverse=True)
return activities
async def _save_admin_activities(self, activities: list[dict[str, Any]]) -> None:
await KeyValue.update_or_create(
key=self.ADMIN_ACTIVITY_KEY,
defaults={"value": {"activities": activities}},
)
def _normalize_admin_activity(self, activity: Any) -> Optional[dict[str, Any]]:
if not isinstance(activity, dict):
return None
action = self._normalize_admin_activity_text(activity.get("action"))
target_type = self._normalize_admin_activity_text(
activity.get("target_type") or activity.get("targetType") or "system"
)
if not action:
return None
target_name = self._normalize_admin_activity_text(
activity.get("target_name") or activity.get("targetName")
)
created_at = activity.get("created_at") or activity.get("createdAt")
if isinstance(created_at, datetime):
created_at = created_at.isoformat()
created_at = str(created_at or "")
if not created_at:
return None
target_id = activity.get("target_id")
if target_id is None:
target_id = activity.get("targetId")
count = activity.get("count", 1)
try:
count = max(int(count), 1)
except (TypeError, ValueError):
count = 1
meta = activity.get("meta")
if not isinstance(meta, dict):
meta = {}
activity_id = self._normalize_admin_activity_text(activity.get("id"))
if not activity_id:
activity_id = self._build_admin_activity_id(
action=action,
target_type=target_type,
target_id=target_id,
target_name=target_name,
timestamp=None,
seed=created_at,
)
return {
"id": activity_id,
"action": action,
"target_type": target_type,
"target_id": target_id,
"target_name": target_name,
"count": count,
"meta": meta,
"created_at": created_at,
}
def _normalize_admin_activity_text(self, value: Any) -> str:
return str(value or "").strip()[: self.MAX_ADMIN_ACTIVITY_TEXT_LENGTH]
def _filter_admin_activities(
self,
activities: list[dict[str, Any]],
action: str,
target_type: str,
keyword: str,
) -> list[dict[str, Any]]:
filtered_activities = []
for activity in activities:
if action and str(activity.get("action") or "").lower() != action:
continue
if target_type and str(activity.get("target_type") or "").lower() != target_type:
continue
if keyword and not self._activity_matches_keyword(activity, keyword):
continue
filtered_activities.append(activity)
return filtered_activities
def _activity_matches_keyword(self, activity: dict[str, Any], keyword: str) -> bool:
searchable_values = [
activity.get("action"),
activity.get("target_type"),
activity.get("target_type"),
activity.get("target_id"),
activity.get("target_id"),
activity.get("target_name"),
activity.get("target_name"),
]
meta = activity.get("meta")
if isinstance(meta, dict):
searchable_values.extend(meta.values())
return any(keyword in str(value or "").lower() for value in searchable_values)
def _build_admin_activity_options(
self,
activities: list[dict[str, Any]],
field: str,
) -> list[dict[str, Any]]:
counters: dict[str, dict[str, Any]] = {}
for activity in activities:
raw_value = self._normalize_admin_activity_text(activity.get(field))
if not raw_value:
continue
value = raw_value.lower()
if value not in counters:
counters[value] = {"label": raw_value, "count": 0}
counters[value]["count"] += 1
return [
{
"value": value,
"label": option["label"],
"count": option["count"],
}
for value, option in sorted(
counters.items(),
key=lambda item: (-item[1]["count"], item[0]),
)
]
def _build_admin_activity_id(
self,
action: str,
target_type: str,
target_id: Optional[Any],
target_name: str,
timestamp: Optional[datetime],
seed: Optional[str] = None,
) -> str:
timestamp_seed = (
str(int(timestamp.timestamp() * 1000)) if timestamp else str(seed or "activity")
)
digest = hashlib.sha1(
f"{timestamp_seed}:{action}:{target_type}:{target_id}:{target_name}".encode("utf-8")
).hexdigest()[:10]
return f"act_{timestamp_seed}_{digest}"
def _build_file_activity_name(self, file_code: FileCodes) -> str:
return (file_code.prefix + file_code.suffix) or file_code.code
async def _get_file_view_presets(self) -> list[dict[str, Any]]:
record = await KeyValue.filter(key=self.FILE_VIEW_PRESETS_KEY).first()
raw_presets = record.value if record else []
if isinstance(raw_presets, dict):
raw_presets = raw_presets.get("presets") or raw_presets.get("items") or []
if not isinstance(raw_presets, list):
return []
presets = []
seen_ids = set()
for raw_preset in raw_presets:
try:
preset = self._normalize_file_view_preset(raw_preset)
except HTTPException:
continue
if not preset or preset["id"] in seen_ids:
continue
seen_ids.add(preset["id"])
presets.append(preset)
if len(presets) >= self.MAX_VIEW_PRESETS:
break
return presets
async def _save_file_view_presets(self, presets: list[dict[str, Any]]) -> None:
await KeyValue.update_or_create(
key=self.FILE_VIEW_PRESETS_KEY,
defaults={"value": {"presets": presets}},
)
def _normalize_file_view_preset(self, preset: Any) -> Optional[dict[str, Any]]:
if not isinstance(preset, dict):
return None
preset_id = str(preset.get("id") or "").strip()
raw_name = str(preset.get("name") or "").strip()
if not raw_name:
return None
name = self._normalize_file_view_preset_name(raw_name)
if not preset_id:
preset_id = self._build_file_view_preset_id(name)
filters = preset.get("filters") or preset.get("params") or {}
normalized_filters = self._normalize_file_view_preset_filters(filters)
created_at = preset.get("created_at")
updated_at = preset.get("updated_at") or preset.get("updatedAt")
return {
"id": preset_id,
"name": name,
"filters": normalized_filters,
"created_at": created_at,
"updated_at": updated_at,
}
def _normalize_file_view_preset_name(self, name: Any) -> str:
normalized_name = str(name or "").strip()
if not normalized_name:
raise HTTPException(status_code=400, detail="请输入视图名称")
return normalized_name[: self.MAX_VIEW_PRESET_NAME_LENGTH]
def _normalize_file_view_preset_filters(self, filters: Any) -> dict[str, Any]:
if not isinstance(filters, dict):
filters = {}
sort_by = str(filters.get("sortBy") or filters.get("sort_by") or "created_at")
sort_by = sort_by.replace("-", "_").strip().lower()
if sort_by not in self.VIEW_PRESET_SORT_FIELDS:
sort_by = "created_at"
sort_order = str(filters.get("sortOrder") or filters.get("sort_order") or "desc")
sort_order = sort_order.strip().lower()
if sort_order not in {"asc", "desc"}:
sort_order = "desc"
size = filters.get("size", 10)
try:
size = int(size)
except (TypeError, ValueError):
size = 10
return {
"keyword": str(filters.get("keyword") or "").strip()[
: self.MAX_VIEW_PRESET_KEYWORD_LENGTH
],
"status": self._normalize_file_view_preset_choice(
filters.get("status"), self.VIEW_PRESET_STATUS_VALUES
),
"type": self._normalize_file_view_preset_choice(
filters.get("type"), self.VIEW_PRESET_TYPE_VALUES
),
"health": self._normalize_file_view_preset_choice(
filters.get("health"), self.VIEW_PRESET_HEALTH_VALUES
),
"sort_by": sort_by,
"sort_order": sort_order,
"size": min(max(size, 1), 100),
}
def _normalize_file_view_preset_choice(self, value: Any, allowed_values: set[str]) -> str:
normalized_value = str(value or "all").strip().lower()
if normalized_value not in allowed_values:
return "all"
return normalized_value
def _build_file_view_preset_id(
self, name: str, timestamp: Optional[datetime] = None
) -> str:
seed = int(timestamp.timestamp() * 1000) if timestamp else "saved"
digest = hashlib.sha1(name.encode("utf-8")).hexdigest()[:8]
return f"view_{seed}_{digest}"
def _build_file_status_insights(
self,
file_code: FileCodes,
detail: dict[str, Any],
now: datetime,
has_download_limit: bool,
is_permanent: bool,
can_download: bool,
) -> dict[str, Any]:
remaining_downloads = detail["remaining_downloads"]
seconds_until_expiration = self._seconds_between(now, file_code.expired_at)
age_seconds = self._seconds_between(file_code.created_at, now)
reasons = []
if detail["is_expired"]:
reasons.append("expired")
if has_download_limit and remaining_downloads == 0:
reasons.append("download_limit_exhausted")
if seconds_until_expiration is not None and 0 < seconds_until_expiration <= 86400:
reasons.append("expires_soon")
if file_code.used_count == 0:
reasons.append("never_retrieved")
if not can_download:
reasons.append("storage_metadata_incomplete")
if file_code.is_chunked:
reasons.append("chunked_upload")
severity = "success"
state = "available"
next_action = "monitor"
if detail["is_expired"] or (has_download_limit and remaining_downloads == 0):
severity = "danger"
state = "expired"
next_action = "extend_or_delete"
elif not can_download:
severity = "danger"
state = "storage_incomplete"
next_action = "inspect_storage"
elif "expires_soon" in reasons:
severity = "warning"
state = "expiring_soon"
next_action = "extend_expiration"
elif is_permanent:
state = "permanent"
next_action = "monitor"
return {
"severity": severity,
"state": state,
"next_action": next_action,
"reasons": reasons,
"metrics": {
"age_seconds": max(age_seconds or 0, 0),
"seconds_until_expiration": seconds_until_expiration,
"remaining_downloads": remaining_downloads,
"used_count": file_code.used_count,
},
}
def _build_file_timeline(
self,
file_code: FileCodes,
detail: dict[str, Any],
now: datetime,
has_download_limit: bool,
is_permanent: bool,
is_text: bool,
) -> list[dict[str, Any]]:
remaining_downloads = detail["remaining_downloads"]
seconds_until_expiration = self._seconds_between(now, file_code.expired_at)
timeline = [
{
"key": "created",
"status": "done",
"severity": "success",
"timestamp": file_code.created_at,
},
{
"key": "content_ready",
"status": "done",
"severity": "success",
"timestamp": file_code.created_at,
"detail": "text" if is_text else "file",
},
]
if file_code.upload_id:
timeline.append(
{
"key": "upload_session",
"status": "done",
"severity": "info",
"timestamp": file_code.created_at,
"detail": file_code.upload_id,
}
)
if is_permanent:
timeline.append(
{
"key": "expiration_policy",
"status": "unlimited",
"severity": "success",
"timestamp": None,
}
)
elif file_code.expired_at is not None:
expired = seconds_until_expiration is not None and seconds_until_expiration <= 0
timeline.append(
{
"key": "expiration_policy",
"status": "expired" if expired else "pending",
"severity": "danger" if expired else "warning",
"timestamp": file_code.expired_at,
"value": seconds_until_expiration,
}
)
if has_download_limit:
exhausted = remaining_downloads == 0
timeline.append(
{
"key": "download_limit",
"status": "exhausted" if exhausted else "active",
"severity": "danger" if exhausted else "info",
"timestamp": None,
"value": remaining_downloads,
}
)
else:
timeline.append(
{
"key": "download_limit",
"status": "unlimited",
"severity": "success",
"timestamp": None,
"value": None,
}
)
timeline.append(
{
"key": "retrieved",
"status": "done" if file_code.used_count > 0 else "pending",
"severity": "success" if file_code.used_count > 0 else "neutral",
"timestamp": None,
"value": file_code.used_count,
}
)
return timeline
def _seconds_between(
self, start: Optional[datetime], end: Optional[datetime]
) -> Optional[int]:
if start is None or end is None:
return None
if start.tzinfo is None and end.tzinfo is not None:
end = end.replace(tzinfo=None)
elif start.tzinfo is not None and end.tzinfo is None:
start = start.replace(tzinfo=None)
return int((end - start).total_seconds())
def _build_policy_action_update(
self,
file_code: FileCodes,
action: str,
now: datetime,
download_limit: Optional[int],
) -> dict[str, Any]:
if action == "extend_24h":
return {"expired_at": self._extended_expiration(file_code.expired_at, now, hours=24)}
if action == "extend_7d":
return {"expired_at": self._extended_expiration(file_code.expired_at, now, days=7)}
if action == "make_permanent":
return {"expired_at": None, "expired_count": -1}
if action == "reset_download_limit":
next_limit = download_limit if download_limit is not None else 5
if next_limit < 1:
raise HTTPException(status_code=400, detail="取件次数必须大于 0")
return {"expired_count": next_limit}
raise HTTPException(status_code=400, detail="不支持的策略动作")
def _extended_expiration(
self,
expired_at: Optional[datetime],
now: datetime,
**duration: int,
) -> datetime:
base_time = now
if expired_at is not None:
comparable_expired_at = self._align_datetime(expired_at, now)
if comparable_expired_at > now:
base_time = comparable_expired_at
return base_time + timedelta(**duration)
def _align_datetime(self, value: datetime, reference: datetime) -> datetime:
if value.tzinfo is None and reference.tzinfo is not None:
return value.replace(tzinfo=reference.tzinfo)
if value.tzinfo is not None and reference.tzinfo is None:
return value.replace(tzinfo=None)
return value
def _match_admin_file(
self,
item: dict[str, Any],
keyword: str,
status: str,
file_type: str,
health: str,
) -> bool:
if status == "active" and item["is_expired"]:
return False
if status == "expired" and not item["is_expired"]:
return False
if file_type == "text" and not item["is_text"]:
return False
if file_type == "file" and item["is_text"]:
return False
if file_type == "chunked" and not item["is_chunked"]:
return False
if not self._match_admin_file_health(item, health):
return False
if not keyword:
return True
search_values = [
item.get("code"),
item.get("name"),
item.get("prefix"),
item.get("suffix"),
item.get("file_hash"),
item.get("text"),
]
return any(keyword in str(value).lower() for value in search_values if value)
def _match_admin_file_health(self, item: dict[str, Any], health: str) -> bool:
if not health or health == "all":
return True
status_insights = item.get("status_insights") or {}
severity = status_insights.get("severity")
state = status_insights.get("state")
reasons = set(status_insights.get("reasons") or [])
if health == "attention":
return severity in {"danger", "warning"}
if health == "danger":
return severity == "danger"
if health == "warning":
return severity == "warning"
if health == "expired":
return state == "expired" or item.get("is_expired") is True
if health == "expiring_soon":
return "expires_soon" in reasons
if health == "storage_issue":
return state == "storage_incomplete" or "storage_metadata_incomplete" in reasons
if health == "never_retrieved":
return "never_retrieved" in reasons
if health == "healthy":
return severity == "success"
if health == "permanent":
return state == "permanent"
return True
def _normalize_sort_by(self, sort_by: str) -> str:
normalized = sort_by.replace("-", "_").strip().lower()
if normalized not in self.SORT_FIELDS:
return "created_at"
return normalized
def _get_sort_value(self, item: dict[str, Any], sort_by: str):
def date_value(value: Any) -> float:
if value is None:
return 0
if isinstance(value, datetime):
return value.timestamp()
return 0
sort_map = {
"created_at": date_value(item.get("created_at")),
"createdat": date_value(item.get("created_at")),
"expired_at": date_value(item.get("expired_at")),
"expiredat": date_value(item.get("expired_at")),
"name": item.get("name") or "",
"size": item.get("size") or 0,
"used_count": item.get("used_count") or 0,
"usedcount": item.get("used_count") or 0,
"code": item.get("code") or "",
}
return sort_map.get(sort_by)
async def download_file(self, file_id: int):
file_code = await FileCodes.filter(id=file_id).first()
if not file_code:
raise HTTPException(status_code=404, detail="文件不存在")
if file_code.text:
return APIResponse(detail=file_code.text)
else:
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)
file_code = await FileCodes.filter(id=file_id).first()
if not file_code:
raise HTTPException(status_code=404, detail="文件不存在")
if file_code.text is None:
raise HTTPException(status_code=400, detail="仅文本分享支持预览")
content = file_code.text
preview = content[:max_chars]
return {
"id": file_code.id,
"code": file_code.code,
"name": f"{file_code.prefix}{file_code.suffix}",
"type": "text",
"content": preview,
"length": len(content),
"preview_length": len(preview),
"truncated": len(content) > max_chars,
"max_chars": max_chars,
"created_at": file_code.created_at,
"expired_at": file_code.expired_at,
}
async def share_local_file(self, item):
local_file = LocalFileClass(item.filename)
if not await local_file.exists():
raise HTTPException(status_code=404, detail="文件不存在")
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": name,
"path": local_file.file,
"id": record.id,
}
# —— 门面 re-export:既有 import 路径(apps.admin.services.ConfigService 等)保持兼容 ——
from apps.admin.config_service import ConfigService, keyvalue_write_lock # noqa: E402,F401
from apps.admin.local_files import LocalFileClass, LocalFileService # noqa: E402,F401