Refactor code structure for improved readability and maintainability

app/services/task_handlers.py

@@ -10,6 +10,7 @@ from app.repositories.playlist import PlaylistRepository
 from app.repositories.sound import SoundRepository
 from app.services.credit import CreditService
 from app.services.player import PlayerService
+from app.services.vlc_player import VLCPlayerService
 
 logger = get_logger(__name__)
 
@@ -48,16 +49,23 @@ class TaskHandlerRegistry:
         """Execute a task based on its type."""
         handler = self._handlers.get(task.task_type)
         if not handler:
-            raise TaskExecutionError(f"No handler registered for task type: {task.task_type}")
+            msg = f"No handler registered for task type: {task.task_type}"
+            raise TaskExecutionError(msg)
 
-        logger.info(f"Executing task {task.id} ({task.task_type.value}): {task.name}")
+        logger.info(
+            "Executing task %s (%s): %s",
+            task.id,
+            task.task_type.value,
+            task.name,
+        )
 
         try:
             await handler(task)
-            logger.info(f"Task {task.id} executed successfully")
+            logger.info("Task %s executed successfully", task.id)
         except Exception as e:
-            logger.exception(f"Task {task.id} execution failed: {e!s}")
-            raise TaskExecutionError(f"Task execution failed: {e!s}") from e
+            logger.exception("Task %s execution failed", task.id)
+            msg = f"Task execution failed: {e!s}"
+            raise TaskExecutionError(msg) from e
 
     async def _handle_credit_recharge(self, task: ScheduledTask) -> None:
         """Handle credit recharge task."""
@@ -69,14 +77,15 @@ class TaskHandlerRegistry:
             try:
                 user_id_int = int(user_id)
             except (ValueError, TypeError) as e:
-                raise TaskExecutionError(f"Invalid user_id format: {user_id}") from e
+                msg = f"Invalid user_id format: {user_id}"
+                raise TaskExecutionError(msg) from e
 
             stats = await self.credit_service.recharge_user_credits(user_id_int)
-            logger.info(f"Recharged credits for user {user_id}: {stats}")
+            logger.info("Recharged credits for user %s: %s", user_id, stats)
         else:
             # Recharge all users (system task)
             stats = await self.credit_service.recharge_all_users_credits()
-            logger.info(f"Recharged credits for all users: {stats}")
+            logger.info("Recharged credits for all users: %s", stats)
 
     async def _handle_play_sound(self, task: ScheduledTask) -> None:
         """Handle play sound task."""
@@ -84,41 +93,54 @@ class TaskHandlerRegistry:
         sound_id = parameters.get("sound_id")
 
         if not sound_id:
-            raise TaskExecutionError("sound_id parameter is required for PLAY_SOUND tasks")
+            msg = "sound_id parameter is required for PLAY_SOUND tasks"
+            raise TaskExecutionError(msg)
 
         try:
             # Handle both integer and string sound IDs
             sound_id_int = int(sound_id)
         except (ValueError, TypeError) as e:
-            raise TaskExecutionError(f"Invalid sound_id format: {sound_id}") from e
+            msg = f"Invalid sound_id format: {sound_id}"
+            raise TaskExecutionError(msg) from e
 
         # Check if this is a user task (has user_id)
         if task.user_id:
             # User task: use credit-aware playback
-            from app.services.vlc_player import VLCPlayerService
 
             vlc_service = VLCPlayerService(self.db_session_factory)
             try:
-                result = await vlc_service.play_sound_with_credits(sound_id_int, task.user_id)
-                logger.info(f"Played sound {result.get('sound_name', sound_id)} via scheduled task for user {task.user_id} (credits deducted: {result.get('credits_deducted', 0)})")
+                result = await vlc_service.play_sound_with_credits(
+                    sound_id_int, task.user_id,
+                )
+                logger.info(
+                    (
+                        "Played sound %s via scheduled task for user %s "
+                        "(credits deducted: %s)"
+                    ),
+                    result.get("sound_name", sound_id),
+                    task.user_id,
+                    result.get("credits_deducted", 0),
+                )
             except Exception as e:
                 # Convert HTTP exceptions or credit errors to task execution errors
-                raise TaskExecutionError(f"Failed to play sound with credits: {e!s}") from e
+                msg = f"Failed to play sound with credits: {e!s}"
+                raise TaskExecutionError(msg) from e
         else:
             # System task: play without credit deduction
             sound = await self.sound_repository.get_by_id(sound_id_int)
             if not sound:
-                raise TaskExecutionError(f"Sound not found: {sound_id}")
+                msg = f"Sound not found: {sound_id}"
+                raise TaskExecutionError(msg)
 
-            from app.services.vlc_player import VLCPlayerService
 
             vlc_service = VLCPlayerService(self.db_session_factory)
             success = await vlc_service.play_sound(sound)
 
             if not success:
-                raise TaskExecutionError(f"Failed to play sound {sound.filename}")
+                msg = f"Failed to play sound {sound.filename}"
+                raise TaskExecutionError(msg)
 
-            logger.info(f"Played sound {sound.filename} via scheduled system task")
+            logger.info("Played sound %s via scheduled system task", sound.filename)
 
     async def _handle_play_playlist(self, task: ScheduledTask) -> None:
         """Handle play playlist task."""
@@ -128,31 +150,34 @@ class TaskHandlerRegistry:
         shuffle = parameters.get("shuffle", False)
 
         if not playlist_id:
-            raise TaskExecutionError("playlist_id parameter is required for PLAY_PLAYLIST tasks")
+            msg = "playlist_id parameter is required for PLAY_PLAYLIST tasks"
+            raise TaskExecutionError(msg)
 
         try:
             # Handle both integer and string playlist IDs
             playlist_id_int = int(playlist_id)
         except (ValueError, TypeError) as e:
-            raise TaskExecutionError(f"Invalid playlist_id format: {playlist_id}") from e
+            msg = f"Invalid playlist_id format: {playlist_id}"
+            raise TaskExecutionError(msg) from e
 
         # Get the playlist from database
         playlist = await self.playlist_repository.get_by_id(playlist_id_int)
         if not playlist:
-            raise TaskExecutionError(f"Playlist not found: {playlist_id}")
+            msg = f"Playlist not found: {playlist_id}"
+            raise TaskExecutionError(msg)
 
         # Load playlist in player
         await self.player_service.load_playlist(playlist_id_int)
 
         # Set play mode if specified
         if play_mode in ["continuous", "loop", "loop_one", "random", "single"]:
-            self.player_service.set_mode(play_mode)
+            await self.player_service.set_mode(play_mode)
 
         # Enable shuffle if requested
         if shuffle:
-            self.player_service.set_shuffle(True)
+            await self.player_service.set_shuffle(shuffle=True)
 
         # Start playing
         await self.player_service.play()
 
-        logger.info(f"Started playing playlist {playlist.name} via scheduled task")
+        logger.info("Started playing playlist %s via scheduled task", playlist.name)