feat: add FastAPI manager API compatibility baseline

main/manager-api-fastapi/app/routers/voiceclone.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+from fastapi import APIRouter, Depends, File, Form, Request, UploadFile
+from sqlalchemy.ext.asyncio import AsyncSession
+from starlette.responses import Response
+
+from app.core.database import get_db
+from app.core.errors import AppError
+from app.core.i18n import message_for
+from app.core.responses import JavaJSONResponse, error_response, ok
+from app.core.security import require_normal, require_super_admin
+from app.schemas.voiceclone import VoiceCloneRenameRequest, VoiceCloneTrainRequest, VoiceResourceCreateRequest
+from app.services.voiceclone import VoiceCloneService
+
+voiceclone_router = APIRouter()
+SessionDep = Annotated[AsyncSession, Depends(get_db)]
+VoiceFile = Annotated[UploadFile, File(alias="voiceFile")]
+VoiceIdForm = Annotated[str, Form(alias="id")]
+
+
+def _query_map(request: Request) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    for key, value in request.query_params.multi_items():
+        if key in result:
+            previous = result[key]
+            result[key] = [*previous, value] if isinstance(previous, list) else [previous, value]
+        else:
+            result[key] = value
+    return result
+
+
+# Static voiceResource paths deliberately precede /voiceResource/{id}.
+@voiceclone_router.get("/voiceResource/ttsPlatforms")
+async def tts_platforms(
+    request: Request,
+    session: SessionDep,
+) -> JavaJSONResponse:
+    require_super_admin(request)
+    return ok(await VoiceCloneService(session).tts_platforms())
+
+
+@voiceclone_router.get("/voiceResource/user/{user_id}")
+async def voice_resources_by_user(
+    user_id: int,
+    request: Request,
+    session: SessionDep,
+) -> JavaJSONResponse:
+    require_normal(request)
+    return ok(await VoiceCloneService(session).get_by_user(user_id))
+
+
+@voiceclone_router.get("/voiceResource")
+async def page_voice_resources(
+    request: Request,
+    session: SessionDep,
+) -> JavaJSONResponse:
+    require_super_admin(request)
+    return ok(await VoiceCloneService(session).page(_query_map(request)))
+
+
+@voiceclone_router.get("/voiceResource/{voice_id}")
+async def get_voice_resource(
+    voice_id: str,
+    request: Request,
+    session: SessionDep,
+) -> JavaJSONResponse:
+    require_super_admin(request)
+    return ok(await VoiceCloneService(session).get_detail(voice_id))
+
+
+@voiceclone_router.post("/voiceResource")
+async def create_voice_resource(
+    request: Request,
+    session: SessionDep,
+    body: VoiceResourceCreateRequest | None = None,
+) -> JavaJSONResponse:
+    user = require_super_admin(request)
+    if body is None:
+        return error_response(request, 10145)
+    if body.model_id is None or body.model_id == "":
+        return error_response(request, 10146)
+    if not body.voice_ids:
+        return error_response(request, 10147)
+    if body.user_id is None:
+        return error_response(request, 10148)
+    try:
+        await VoiceCloneService(session).create_resources(body, actor=user)
+        return ok()
+    except AppError:
+        raise
+    except RuntimeError as exc:
+        return error_response(request, 10065, str(exc))
+
+
+@voiceclone_router.delete("/voiceResource/{voice_id}")
+async def delete_voice_resource(
+    voice_id: str,
+    request: Request,
+    session: SessionDep,
+) -> JavaJSONResponse:
+    require_super_admin(request)
+    ids = voice_id.split(",") if voice_id else []
+    if not ids:
+        return error_response(request, 10149)
+    await VoiceCloneService(session).delete(ids)
+    return ok()
+
+
+@voiceclone_router.get("/voiceClone")
+async def page_voice_clones(
+    request: Request,
+    session: SessionDep,
+) -> JavaJSONResponse:
+    user = require_normal(request)
+    return ok(await VoiceCloneService(session).page(_query_map(request), user_id=user.id))
+
+
+@voiceclone_router.post("/voiceClone/upload")
+async def upload_voice_clone(
+    request: Request,
+    session: SessionDep,
+    voice_file: VoiceFile,
+    voice_id: VoiceIdForm = "",
+) -> JavaJSONResponse:
+    user = require_normal(request)
+    service = VoiceCloneService(session)
+    try:
+        content = await voice_file.read()
+        if not content:
+            return error_response(request, 10140)
+        content_type = voice_file.content_type
+        if content_type is None or not content_type.startswith("audio/"):
+            return error_response(request, 10141)
+        filename = voice_file.filename
+        if filename is None or "." not in filename:
+            raise RuntimeError("文件名缺少扩展名")
+        extension = filename[filename.rfind(".") :].lower()
+        if extension not in {".mp3", ".wav"}:
+            return error_response(request, 500, "只允许上传.mp3和.wav格式的文件")
+        if len(content) > 10 * 1024 * 1024:
+            return error_response(request, 10142)
+        await service.check_permission(voice_id, user)
+        await service.upload_voice(voice_id, content)
+        return ok()
+    except Exception as exc:
+        if isinstance(exc, AppError):
+            message = exc.message or message_for(exc.code, request.headers.get("Accept-Language"))
+        else:
+            message = str(exc)
+        return error_response(request, 10143, message)
+
+
+@voiceclone_router.post("/voiceClone/updateName")
+async def update_voice_clone_name(
+    body: VoiceCloneRenameRequest,
+    request: Request,
+    session: SessionDep,
+) -> JavaJSONResponse:
+    user = require_normal(request)
+    if body.id is None or body.id == "":
+        return error_response(request, 10006)
+    if body.name is None or body.name == "":
+        return error_response(request, 10181)
+    service = VoiceCloneService(session)
+    try:
+        await service.check_permission(body.id, user)
+        await service.rename(body.id or "", body.name or "")
+        return ok()
+    except Exception as exc:
+        if isinstance(exc, AppError):
+            message = exc.message or message_for(exc.code, request.headers.get("Accept-Language"))
+        else:
+            message = str(exc)
+        return error_response(request, 10066, message)
+
+
+@voiceclone_router.post("/voiceClone/audio/{voice_id}")
+async def get_voice_clone_audio_id(
+    voice_id: str,
+    request: Request,
+    session: SessionDep,
+) -> JavaJSONResponse:
+    user = require_normal(request)
+    service = VoiceCloneService(session)
+    await service.check_permission(voice_id, user)
+    return ok(await service.create_audio_id(voice_id))
+
+
+@voiceclone_router.get("/voiceClone/play/{download_id}")
+async def play_voice_clone(download_id: str, session: SessionDep) -> Response:
+    try:
+        content = await VoiceCloneService(session).consume_audio(download_id)
+        if content is None:
+            return Response(status_code=404)
+        return Response(
+            content,
+            media_type="audio/wav",
+            headers={
+                "Content-Length": str(len(content)),
+                "Content-Disposition": "inline; filename=voice.wav",
+            },
+        )
+    except Exception:
+        return Response(status_code=500)
+
+
+@voiceclone_router.post("/voiceClone/cloneAudio")
+async def train_voice_clone(
+    body: VoiceCloneTrainRequest,
+    request: Request,
+    session: SessionDep,
+) -> JavaJSONResponse:
+    user = require_normal(request)
+    service = VoiceCloneService(session)
+    await service.check_permission(body.clone_id, user)
+    await service.clone_audio(
+        body.clone_id or "",
+        accept_language=request.headers.get("Accept-Language"),
+    )
+    return ok()