refactor: Create admin enpoints and some renaming of api endpoints

app/api/v1/sounds.py

@@ -13,26 +13,11 @@ from app.repositories.sound import SoundRepository
 from app.services.credit import CreditService, InsufficientCreditsError
 from app.services.extraction import ExtractionInfo, ExtractionService
 from app.services.extraction_processor import extraction_processor
-from app.services.sound_normalizer import NormalizationResults, SoundNormalizerService
-from app.services.sound_scanner import ScanResults, SoundScannerService
 from app.services.vlc_player import VLCPlayerService, get_vlc_player_service
 
 router = APIRouter(prefix="/sounds", tags=["sounds"])
 
 
-async def get_sound_scanner_service(
-    session: Annotated[AsyncSession, Depends(get_db)],
-) -> SoundScannerService:
-    """Get the sound scanner service."""
-    return SoundScannerService(session)
-
-
-async def get_sound_normalizer_service(
-    session: Annotated[AsyncSession, Depends(get_db)],
-) -> SoundNormalizerService:
-    """Get the sound normalizer service."""
-    return SoundNormalizerService(session)
-
 
 async def get_extraction_service(
     session: Annotated[AsyncSession, Depends(get_db)],
@@ -58,216 +43,6 @@ async def get_sound_repository(
     return SoundRepository(session)
 
 
-# SCAN
-@router.post("/scan")
-async def scan_sounds(
-    current_user: Annotated[User, Depends(get_current_active_user_flexible)],
-    scanner_service: Annotated[SoundScannerService, Depends(get_sound_scanner_service)],
-) -> dict[str, ScanResults | str]:
-    """Sync the soundboard directory (add/update/delete sounds)."""
-    # Only allow admins to scan sounds
-    if current_user.role not in ["admin", "superadmin"]:
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="Only administrators can sync sounds",
-        )
-
-    try:
-        results = await scanner_service.scan_soundboard_directory()
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to sync sounds: {e!s}",
-        ) from e
-    else:
-        return {
-            "message": "Sound sync completed",
-            "results": results,
-        }
-
-
-@router.post("/scan/custom")
-async def scan_custom_directory(
-    directory: str,
-    current_user: Annotated[User, Depends(get_current_active_user_flexible)],
-    scanner_service: Annotated[SoundScannerService, Depends(get_sound_scanner_service)],
-    sound_type: str = "SDB",
-) -> dict[str, ScanResults | str]:
-    """Sync a custom directory with the database (add/update/delete sounds)."""
-    # Only allow admins to sync sounds
-    if current_user.role not in ["admin", "superadmin"]:
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="Only administrators can sync sounds",
-        )
-
-    try:
-        results = await scanner_service.scan_directory(directory, sound_type)
-    except ValueError as e:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=str(e),
-        ) from e
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to sync directory: {e!s}",
-        ) from e
-    else:
-        return {
-            "message": f"Sync of directory '{directory}' completed",
-            "results": results,
-        }
-
-
-# NORMALIZE
-@router.post("/normalize/all")
-async def normalize_all_sounds(
-    current_user: Annotated[User, Depends(get_current_active_user_flexible)],
-    normalizer_service: Annotated[
-        SoundNormalizerService, Depends(get_sound_normalizer_service),
-    ],
-    force: Annotated[bool, Query(  # noqa: FBT002
-        description="Force normalization of already normalized sounds",
-    )] = False,
-    one_pass: Annotated[bool | None, Query(
-        description="Use one-pass normalization (overrides config)",
-    )] = None,
-) -> dict[str, NormalizationResults | str]:
-    """Normalize all unnormalized sounds."""
-    # Only allow admins to normalize sounds
-    if current_user.role not in ["admin", "superadmin"]:
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="Only administrators can normalize sounds",
-        )
-
-    try:
-        results = await normalizer_service.normalize_all_sounds(
-            force=force,
-            one_pass=one_pass,
-        )
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to normalize sounds: {e!s}",
-        ) from e
-    else:
-        return {
-            "message": "Sound normalization completed",
-            "results": results,
-        }
-
-
-@router.post("/normalize/type/{sound_type}")
-async def normalize_sounds_by_type(
-    sound_type: str,
-    current_user: Annotated[User, Depends(get_current_active_user_flexible)],
-    normalizer_service: Annotated[
-        SoundNormalizerService, Depends(get_sound_normalizer_service),
-    ],
-    force: Annotated[bool, Query(  # noqa: FBT002
-        description="Force normalization of already normalized sounds",
-    )] = False,
-    one_pass: Annotated[bool | None, Query(
-        description="Use one-pass normalization (overrides config)",
-    )] = None,
-) -> dict[str, NormalizationResults | str]:
-    """Normalize all sounds of a specific type (SDB, TTS, EXT)."""
-    # Only allow admins to normalize sounds
-    if current_user.role not in ["admin", "superadmin"]:
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="Only administrators can normalize sounds",
-        )
-
-    # Validate sound type
-    valid_types = ["SDB", "TTS", "EXT"]
-    if sound_type not in valid_types:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"Invalid sound type. Must be one of: {', '.join(valid_types)}",
-        )
-
-    try:
-        results = await normalizer_service.normalize_sounds_by_type(
-            sound_type=sound_type,
-            force=force,
-            one_pass=one_pass,
-        )
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to normalize {sound_type} sounds: {e!s}",
-        ) from e
-    else:
-        return {
-            "message": f"Normalization of {sound_type} sounds completed",
-            "results": results,
-        }
-
-
-@router.post("/normalize/{sound_id}")
-async def normalize_sound_by_id(
-    sound_id: int,
-    current_user: Annotated[User, Depends(get_current_active_user_flexible)],
-    normalizer_service: Annotated[
-        SoundNormalizerService, Depends(get_sound_normalizer_service),
-    ],
-    force: Annotated[bool, Query(  # noqa: FBT002
-        description="Force normalization of already normalized sound",
-    )] = False,
-    one_pass: Annotated[bool | None, Query(
-        description="Use one-pass normalization (overrides config)",
-    )] = None,
-) -> dict[str, str]:
-    """Normalize a specific sound by ID."""
-    # Only allow admins to normalize sounds
-    if current_user.role not in ["admin", "superadmin"]:
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="Only administrators can normalize sounds",
-        )
-
-    try:
-        # Get the sound
-        sound = await normalizer_service.sound_repo.get_by_id(sound_id)
-        if not sound:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Sound with ID {sound_id} not found",
-            )
-
-        # Normalize the sound
-        result = await normalizer_service.normalize_sound(
-            sound=sound,
-            force=force,
-            one_pass=one_pass,
-        )
-
-        # Check result status
-        if result["status"] == "error":
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail=f"Failed to normalize sound: {result['error']}",
-            )
-
-        return {
-            "message": f"Sound normalization {result['status']}: {sound.filename}",
-            "status": result["status"],
-            "reason": result["reason"] or "",
-            "normalized_filename": result["normalized_filename"] or "",
-        }
-
-    except HTTPException:
-        # Re-raise HTTPExceptions without wrapping them
-        raise
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to normalize sound: {e!s}",
-        ) from e
-
 
 # EXTRACT
 @router.post("/extract")
@@ -308,19 +83,6 @@ async def create_extraction(
         }
 
 
-@router.get("/extract/status")
-async def get_extraction_processor_status(
-    current_user: Annotated[User, Depends(get_current_active_user_flexible)],
-) -> dict:
-    """Get the status of the extraction processor."""
-    # Only allow admins to see processor status
-    if current_user.role not in ["admin", "superadmin"]:
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="Only administrators can view processor status",
-        )
-
-    return extraction_processor.get_status()
 
 
 @router.get("/extract/{extraction_id}")
@@ -377,7 +139,7 @@ async def get_user_extractions(
 
 
 # VLC PLAYER
-@router.post("/vlc/play/{sound_id}")
+@router.post("/play/{sound_id}")
 async def play_sound_with_vlc(
     sound_id: int,
     current_user: Annotated[User, Depends(get_current_active_user_flexible)],
@@ -445,7 +207,7 @@ async def play_sound_with_vlc(
 
 
 
-@router.post("/vlc/stop-all")
+@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)],