feat: Implement voice design management with CRUD operations and integrate into frontend

qwen3-tts-backend/api/tts.py

@@ -98,7 +98,8 @@ async def process_voice_design_job(
     user_id: int,
     request_data: dict,
     backend_type: str,
-    db_url: str
+    db_url: str,
+    saved_voice_id: Optional[str] = None
 ):
     from core.database import SessionLocal
     from core.tts_service import TTSServiceFactory
@@ -125,7 +126,10 @@ async def process_voice_design_job(
 
         backend = await TTSServiceFactory.get_backend(backend_type, user_api_key)
 
-        audio_bytes, sample_rate = await backend.generate_voice_design(request_data)
+        if backend_type == "aliyun" and saved_voice_id:
+            audio_bytes, sample_rate = await backend.generate_voice_design(request_data, saved_voice_id)
+        else:
+            audio_bytes, sample_rate = await backend.generate_voice_design(request_data)
 
         timestamp = datetime.utcnow().strftime("%Y%m%d_%H%M%S")
         filename = f"{user_id}_{job_id}_{timestamp}.wav"
@@ -374,7 +378,7 @@ async def create_voice_design_job(
     db: Session = Depends(get_db)
 ):
     from core.security import decrypt_api_key
-    from db.crud import get_user_preferences, can_user_use_local_model
+    from db.crud import get_user_preferences, can_user_use_local_model, get_voice_design, update_voice_design_usage
 
     user_prefs = get_user_preferences(db, current_user.id)
     preferred_backend = user_prefs.get("default_backend", "aliyun")
@@ -383,6 +387,24 @@ async def create_voice_design_job(
 
     backend_type = req_data.backend if hasattr(req_data, 'backend') and req_data.backend else preferred_backend
 
+    saved_voice_id = None
+
+    if req_data.saved_design_id:
+        saved_design = get_voice_design(db, req_data.saved_design_id, current_user.id)
+        if not saved_design:
+            raise HTTPException(status_code=404, detail="Saved voice design not found")
+
+        if saved_design.backend_type != backend_type:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Saved design backend ({saved_design.backend_type}) doesn't match current backend ({backend_type})"
+            )
+
+        req_data.instruct = saved_design.instruct
+        saved_voice_id = saved_design.aliyun_voice_id
+
+        update_voice_design_usage(db, req_data.saved_design_id, current_user.id)
+
     if backend_type == "local" and not can_use_local:
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
@@ -399,8 +421,9 @@ async def create_voice_design_job(
         validate_text_length(req_data.text)
         language = validate_language(req_data.language)
 
-        if not req_data.instruct or not req_data.instruct.strip():
-            raise ValueError("Instruct parameter is required for voice design")
+        if not req_data.saved_design_id:
+            if not req_data.instruct or not req_data.instruct.strip():
+                raise ValueError("Instruct parameter is required when saved_design_id is not provided")
 
         params = validate_generation_params({
             'max_new_tokens': req_data.max_new_tokens,
@@ -443,7 +466,8 @@ async def create_voice_design_job(
         current_user.id,
         request_data,
         backend_type,
-        str(settings.DATABASE_URL)
+        str(settings.DATABASE_URL),
+        saved_voice_id
     )
 
     return {

qwen3-tts-backend/api/voice_designs.py

@@ -0,0 +1,97 @@
+import logging
+from fastapi import APIRouter, Depends, HTTPException, status, Request
+from sqlalchemy.orm import Session
+from typing import Optional
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+
+from core.database import get_db
+from api.auth import get_current_user
+from db.models import User
+from db import crud
+from schemas.voice_design import (
+    VoiceDesignCreate,
+    VoiceDesignResponse,
+    VoiceDesignUpdate,
+    VoiceDesignListResponse
+)
+
+logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/voice-designs", tags=["voice-designs"])
+limiter = Limiter(key_func=get_remote_address)
+
+@router.post("", response_model=VoiceDesignResponse, status_code=status.HTTP_201_CREATED)
+@limiter.limit("30/minute")
+async def save_voice_design(
+    request: Request,
+    data: VoiceDesignCreate,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    try:
+        design = crud.create_voice_design(
+            db=db,
+            user_id=current_user.id,
+            name=data.name,
+            instruct=data.instruct,
+            backend_type=data.backend_type,
+            aliyun_voice_id=data.aliyun_voice_id,
+            meta_data=data.meta_data,
+            preview_text=data.preview_text
+        )
+        return VoiceDesignResponse.from_orm(design)
+    except Exception as e:
+        logger.error(f"Failed to save voice design: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Failed to save voice design")
+
+@router.get("", response_model=VoiceDesignListResponse)
+@limiter.limit("30/minute")
+async def list_voice_designs(
+    request: Request,
+    backend_type: Optional[str] = None,
+    skip: int = 0,
+    limit: int = 100,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    designs = crud.list_voice_designs(db, current_user.id, backend_type, skip, limit)
+    return VoiceDesignListResponse(designs=[VoiceDesignResponse.from_orm(d) for d in designs], total=len(designs))
+
+@router.get("/{design_id}", response_model=VoiceDesignResponse)
+@limiter.limit("30/minute")
+async def get_voice_design(
+    request: Request,
+    design_id: int,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    design = crud.get_voice_design(db, design_id, current_user.id)
+    if not design:
+        raise HTTPException(status_code=404, detail="Voice design not found")
+    return VoiceDesignResponse.from_orm(design)
+
+@router.patch("/{design_id}", response_model=VoiceDesignResponse)
+@limiter.limit("30/minute")
+async def update_voice_design(
+    request: Request,
+    design_id: int,
+    data: VoiceDesignUpdate,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    design = crud.update_voice_design(db, design_id, current_user.id, data.name)
+    if not design:
+        raise HTTPException(status_code=404, detail="Voice design not found")
+    return VoiceDesignResponse.from_orm(design)
+
+@router.delete("/{design_id}", status_code=status.HTTP_204_NO_CONTENT)
+@limiter.limit("30/minute")
+async def delete_voice_design(
+    request: Request,
+    design_id: int,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    success = crud.delete_voice_design(db, design_id, current_user.id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Voice design not found")