145 lines
4.8 KiB
Python
145 lines
4.8 KiB
Python
"""Sound management API endpoints."""
|
|
|
|
from typing import Annotated
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, Query, status
|
|
from sqlmodel.ext.asyncio.session import AsyncSession
|
|
|
|
from app.core.database import get_db, get_session_factory
|
|
from app.core.dependencies import get_current_active_user_flexible
|
|
from app.models.user import User
|
|
from app.repositories.sound import SortOrder, SoundRepository, SoundSortField
|
|
from app.schemas.sound import SoundResponse, SoundsListResponse
|
|
from app.services.favorite import FavoriteService
|
|
from app.services.vlc_player import VLCPlayerService, get_vlc_player_service
|
|
|
|
router = APIRouter(prefix="/sounds", tags=["sounds"])
|
|
|
|
|
|
def get_vlc_player() -> VLCPlayerService:
|
|
"""Get the VLC player service."""
|
|
return get_vlc_player_service(get_session_factory())
|
|
|
|
|
|
def get_favorite_service() -> FavoriteService:
|
|
"""Get the favorite service."""
|
|
return FavoriteService(get_session_factory())
|
|
|
|
|
|
async def get_sound_repository(
|
|
session: Annotated[AsyncSession, Depends(get_db)],
|
|
) -> SoundRepository:
|
|
"""Get the sound repository."""
|
|
return SoundRepository(session)
|
|
|
|
|
|
@router.get("/")
|
|
async def get_sounds( # noqa: PLR0913
|
|
current_user: Annotated[User, Depends(get_current_active_user_flexible)],
|
|
sound_repo: Annotated[SoundRepository, Depends(get_sound_repository)],
|
|
favorite_service: Annotated[FavoriteService, Depends(get_favorite_service)],
|
|
types: Annotated[
|
|
list[str] | None,
|
|
Query(description="Filter by sound types (e.g., SDB, TTS, EXT)"),
|
|
] = None,
|
|
search: Annotated[
|
|
str | None,
|
|
Query(description="Search sounds by name"),
|
|
] = None,
|
|
sort_by: Annotated[
|
|
SoundSortField | None,
|
|
Query(description="Sort by field"),
|
|
] = None,
|
|
sort_order: Annotated[
|
|
SortOrder,
|
|
Query(description="Sort order (asc or desc)"),
|
|
] = SortOrder.ASC,
|
|
limit: Annotated[
|
|
int | None,
|
|
Query(description="Maximum number of results", ge=1, le=1000),
|
|
] = None,
|
|
offset: Annotated[
|
|
int,
|
|
Query(description="Number of results to skip", ge=0),
|
|
] = 0,
|
|
favorites_only: Annotated[ # noqa: FBT002
|
|
bool,
|
|
Query(description="Show only favorited sounds"),
|
|
] = False,
|
|
) -> SoundsListResponse:
|
|
"""Get sounds with optional search, filtering, and sorting."""
|
|
try:
|
|
sounds = await sound_repo.search_and_sort(
|
|
search_query=search,
|
|
sound_types=types,
|
|
sort_by=sort_by,
|
|
sort_order=sort_order,
|
|
limit=limit,
|
|
offset=offset,
|
|
favorites_only=favorites_only,
|
|
user_id=current_user.id,
|
|
)
|
|
|
|
# Add favorite indicators for each sound
|
|
sound_responses = []
|
|
for sound in sounds:
|
|
is_favorited = await favorite_service.is_sound_favorited(
|
|
current_user.id,
|
|
sound.id,
|
|
)
|
|
favorite_count = await favorite_service.get_sound_favorite_count(sound.id)
|
|
sound_response = SoundResponse.from_sound(
|
|
sound,
|
|
is_favorited,
|
|
favorite_count,
|
|
)
|
|
sound_responses.append(sound_response)
|
|
|
|
except Exception as e:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail=f"Failed to get sounds: {e!s}",
|
|
) from e
|
|
else:
|
|
return SoundsListResponse(sounds=sound_responses)
|
|
|
|
|
|
# VLC PLAYER
|
|
@router.post("/play/{sound_id}")
|
|
async def play_sound_with_vlc(
|
|
sound_id: int,
|
|
current_user: Annotated[User, Depends(get_current_active_user_flexible)],
|
|
vlc_player: Annotated[VLCPlayerService, Depends(get_vlc_player)],
|
|
) -> dict[str, str | int | bool]:
|
|
"""Play a sound using VLC subprocess (requires 1 credit)."""
|
|
try:
|
|
if not current_user.id:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_401_UNAUTHORIZED,
|
|
detail="User ID is required",
|
|
)
|
|
return await vlc_player.play_sound_with_credits(sound_id, current_user.id)
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail=f"Failed to play sound: {e!s}",
|
|
) from e
|
|
|
|
|
|
@router.post("/stop")
|
|
async def stop_all_vlc_instances(
|
|
current_user: Annotated[User, Depends(get_current_active_user_flexible)], # noqa: ARG001
|
|
vlc_player: Annotated[VLCPlayerService, Depends(get_vlc_player)],
|
|
) -> dict:
|
|
"""Stop all running VLC instances."""
|
|
try:
|
|
return await vlc_player.stop_all_vlc_instances()
|
|
|
|
except Exception as e:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail=f"Failed to stop VLC instances: {e!s}",
|
|
) from e
|