Adding Reset and Shuffle Controller and some fix

Controllers/AbstractController.py

@@ -1,6 +1,7 @@
 from abc import ABC, abstractmethod
+from typing import List
 from discord.ext.commands import Context
-from discord import Client, Guild
+from discord import Client, Guild, ClientUser, Member
 from Controllers.PlayerController import PlayersController
 from Music.Player import Player
 from Controllers.ControllerResponse import ControllerResponse
@@ -16,14 +17,29 @@ class AbstractController(ABC):
         self.__player: Player = self.__controller.get_player(ctx.guild)
         self.__guild: Guild = ctx.guild
         self.__ctx: Context = ctx
+        self.__bot_user: ClientUser = self.__bot.user
+        self.__id = self.__bot_user.id
         self.__config = Configs()
         self.__helper = Helper()
         self.__embeds = Embeds()
+        self.__bot_member: Member = self.__get_member()
 
     @abstractmethod
     async def run(self) -> ControllerResponse:
         pass
 
+    @property
+    def id(self) -> int:
+        return self.__id
+
+    @property
+    def bot_member(self) -> Member:
+        return self.__bot_member
+
+    @property
+    def bot_user(self) -> ClientUser:
+        return self.__bot_user
+
     @property
     def guild(self) -> Guild:
         return self.__guild
@@ -55,3 +71,9 @@ class AbstractController(ABC):
     @property
     def embeds(self) -> Embeds:
         return self.__embeds
+
+    def __get_member(self) -> Member:
+        guild_members: List[Member] = self.__guild.members
+        for member in guild_members:
+            if member.id == self.__id:
+                return member

Controllers/LoopController.py

@@ -30,11 +30,10 @@ class LoopController(AbstractController):
             embed = self.embeds.LOOP_ALL_ACTIVATED()
             return ControllerResponse(self.ctx, embed)
         elif args == 'off':
-            self.player.playlist.loop_all()
+            self.player.playlist.loop_off()
             embed = self.embeds.LOOP_DISABLE()
             return ControllerResponse(self.ctx, embed)
         else:
-            self.player.playlist.loop_all()
             error = BadCommandUsage()
             embed = self.embeds.BAD_LOOP_USE()
             return ControllerResponse(self.ctx, embed, error)

Controllers/PlayerController.py

@@ -1,6 +1,6 @@
 from typing import Dict, List, Union
 from Config.Singleton import Singleton
-from discord import Guild, Client, VoiceClient
+from discord import Guild, Client, VoiceClient, Member
 from Music.Player import Player
 
 
@@ -43,3 +43,9 @@ class PlayersController(Singleton):
             print(f'Player for guild {guild.name} created')
 
         return players
+
+    def __get_guild_bot_member(self, guild: Guild) -> Member:
+        members: List[Member] = guild.members
+        for member in members:
+            if member.id == self.__bot.user.id:
+                return member

Controllers/QueueController.py

@@ -13,23 +13,22 @@ class QueueController(AbstractController):
 
     async def run(self) -> ControllerResponse:
         if self.player.playlist.looping_one:
-            info = self.player.playlist.current
-            embed = self.embeds.ONE_SONG_LOOPING(info)
+            song = self.player.playlist.current
+            embed = self.embeds.ONE_SONG_LOOPING(song.info)
             return ControllerResponse(self.ctx, embed)
 
         songs_preload = self.player.playlist.songs_to_preload
         if len(songs_preload) == 0:
-            embed = self.embeds.EMPTY_QUEUE
+            embed = self.embeds.EMPTY_QUEUE()
             return ControllerResponse(self.ctx, embed)
 
         await self.__down.preload(songs_preload)
 
         if self.player.playlist.looping_all:
-            title = self.__config.ALL_SONGS_LOOPING
+            title = self.config.ALL_SONGS_LOOPING
         else:
-            title = self.__config.QUEUE_TITLE
+            title = self.config.QUEUE_TITLE
 
-        title = self.config.QUEUE_TITLE
         total_time = format_time(sum([int(song.duration if song.duration else 0)
                                       for song in songs_preload]))
         total_songs = len(self.player.playlist)

Controllers/ResetController.py

@@ -0,0 +1,20 @@
+from discord.ext.commands import Context
+from discord import Client, Member
+from Controllers.AbstractController import AbstractController
+from Controllers.ControllerResponse import ControllerResponse
+from Controllers.PlayerController import PlayersController
+
+
+class ResetController(AbstractController):
+    def __init__(self, ctx: Context, bot: Client) -> None:
+        super().__init__(ctx, bot)
+        self.__controller = PlayersController(self.bot)
+
+    async def run(self) -> ControllerResponse:
+        try:
+            await self.player.force_stop()
+            await self.bot_member.move_to(None)
+            self.__controller.reset_player(self.guild)
+            return ControllerResponse(self.ctx)
+        except Exception as e:
+            print(f'DEVELOPER NOTE -> Reset Error: {e}')

Controllers/ShuffleController.py

@@ -0,0 +1,26 @@
+from discord.ext.commands import Context
+from discord import Client
+from Controllers.AbstractController import AbstractController
+from Controllers.ControllerResponse import ControllerResponse
+from Exceptions.Exceptions import UnknownError
+from Music.Downloader import Downloader
+
+
+class ShuffleController(AbstractController):
+    def __init__(self, ctx: Context, bot: Client) -> None:
+        super().__init__(ctx, bot)
+        self.__down = Downloader()
+
+    async def run(self) -> ControllerResponse:
+        try:
+            self.player.playlist.shuffle()
+            songs = self.player.playlist.songs_to_preload
+
+            await self.__down.preload(songs)
+            embed = self.embeds.SONGS_SHUFFLED()
+            return ControllerResponse(self.ctx, embed)
+        except Exception as e:
+            print(f'DEVELOPER NOTE -> Error Shuffling: {e}')
+            error = UnknownError()
+            embed = self.embeds.ERROR_SHUFFLING()
+            return ControllerResponse(self.ctx, embed, error)