Added remove_track and swap_track method in player

cogs/basic.py

@@ -312,7 +312,7 @@ class Basic(commands.Cog):
             if player.queue._repeat.mode == voicelink.LoopType.track:
                 await player.set_repeat(voicelink.LoopType.off.name)
                 
-            await player.stop() if player.is_playing else await player.do_next()        
+            await player.stop() if player.is_playing else await player.do_next()
 
     @commands.hybrid_command(name="pause", aliases=get_aliases("pause"))
     @commands.dynamic_cooldown(cooldown_check, commands.BucketType.guild)
@@ -660,17 +660,8 @@ class Basic(commands.Cog):
         if not player.is_privileged(ctx.author):
             return await send(ctx, "missingPerms_queue", ephemeral=True)
 
-        removedTrack = player.queue.remove(position1, position2, member=member)
+        removed_tracks = await player.remove_track(position1, position2, remove_target=member, requester=ctx.author)
-
+        await send(ctx, "removed", len(removed_tracks.keys()))
-        if player.is_ipc_connected and removedTrack:
-            await player.send_ws({
-                "op": "removeTrack",
-                "positions": [track["position"] for track in removedTrack],
-                "track_ids": [track["track"].track_id for track in removedTrack],
-                "current_queue_position": player.queue._position
-            }, requester=ctx.author)
-
-        await send(ctx, "removed", len(removedTrack))
 
     @commands.hybrid_command(name="forward", aliases=get_aliases("forward"))
     @app_commands.describe(position="Input a amount that you to forward to. Exmaple: 1:20")
@@ -769,14 +760,7 @@ class Basic(commands.Cog):
         if not player.is_privileged(ctx.author):
             return await send(ctx, "missingPerms_pos", ephemeral=True)
 
-        track1, track2 = player.queue.swap(position1, position2)
+        track1, track2 = await player.swap_track(position1, position2)        
-        
-        if player.is_ipc_connected:
-            await player.send_ws({
-                "op": "swapTrack",
-                "position1": {"index": position1, "track_id": track1.track_id},
-                "position2": {"index": position2, "track_id": track2.track_id}
-            }, requester=ctx.author)
         await send(ctx, "swapped", track1.title, track2.title)
 
     @commands.hybrid_command(name="move", aliases=get_aliases("move"))
@@ -794,13 +778,7 @@ class Basic(commands.Cog):
         if not player.is_privileged(ctx.author):
             return await send(ctx, "missingPerms_pos", ephemeral=True)
 
-        moved_track = player.queue.move(target, to)
+        moved_track = await player.move_track(target, to, ctx.author)
-        if player.is_ipc_connected:
-            await player.send_ws({
-                "op": "moveTrack",
-                "position": {"index": target, "track_id": moved_track.track_id},
-                "newPosition": {"index": to}
-            }, requester=ctx.author)
         await send(ctx, "moved", moved_track, to)
 
     @commands.hybrid_command(name="lyrics", aliases=get_aliases("lyrics"))

ipc/methods.py

@@ -166,40 +166,16 @@ async def backTo(player: Player, member: Member, data: Dict):
         player.queue.backto(index + 1)
         await player.stop()
 
-async def moveTrack(player: Player, member: Member, data: Dict):
+async def moveTrack(player: Player, member: Member, data: Dict) -> None:
     if not player.is_privileged(member):
         return missingPermission(member.id)
 
-    c = player.queue._position - 1
+    index = data.get("index")
-    position = data.get("position")
+    new_index = data.get("newIndex")
-    new_position = data.get("newPosition")
+    if index == new_index:
-
+        return
-    moveItem = player.queue._queue[position]
-    player.queue._queue.remove(moveItem)
-    player.queue._queue.insert(new_position, moveItem)
     
-    if position > c and new_position <= c:
+    await player.move_track(index, new_index, member)
-        player.queue._position += 1
-
-    elif position < c and new_position >= c:
-        player.queue._position -= 1
-    
-    elif position == c:
-        player.queue._position = new_position + 1
-
-    return {
-        "op": "moveTrack",
-        "position": {
-            "index": position - c,
-            "track_id": moveItem.track_id
-        },
-        "newPosition": {
-            "index": new_position - c
-        },
-        "guild_id": player.guild.id,
-        "requester_id": member.id,
-        "skip_users": [member.id]
-    }
 
 async def addTracks(player: Player, member: Member, data: Dict): 
     raw_tracks = data.get("tracks", [])
@@ -249,28 +225,12 @@ async def repeatTrack(player: Player, member: Member, data: Dict):
     
     await player.set_repeat()
 
-async def removeTrack(player: Player, member: Member, data: Dict):
+async def removeTrack(player: Player, member: Member, data: Dict) -> None:
     if not player.is_privileged(member):
         return missingPermission(member.id)
     
-    position = data.get("position")
+    index, index2 = data.get("index"), data.get("index2")
-    verify_id = data.get("track_id")
+    await player.remove_track(index, index2, requester=member)
-
-    track = player.queue._queue[position]
-    if track.track_id == verify_id:
-        player.queue._queue.remove(track)
-
-    if position < player.queue._position:
-         player.queue._position -= 1
-
-    return {
-        "op": "removeTrack", 
-        "positions": [position],
-        "track_ids": [track.track_id],
-        "current_queue_position": player.queue._position,
-        "requester_id": member.id,
-        "guild_id": player.guild.id
-    }
         
 async def updatePause(player: Player, member: Member, data: Dict):
     pause = data.get("pause", True)

voicelink/player.py

@@ -27,13 +27,7 @@ import function as func
 from math import ceil
 from asyncio import sleep
 from views import InteractiveController
-from typing import (
+from typing import Any, Dict, Optional, Union, List, Tuple
-    Any,
-    Dict,
-    Optional,
-    Union,
-    List
-)
 
 from discord import (
     Client,
@@ -331,7 +325,7 @@ class Player(VoiceProtocol):
         self._logger.debug(f"Player in {self.guild.name}({self.guild.id}) dispatched event {event_type}.")
 
     async def do_next(self):
-        if self.is_playing or not self.channel:
+        if self._current or self.is_playing or not self.channel:
             return
         
         if self._paused:
@@ -368,7 +362,7 @@ class Player(VoiceProtocol):
                 self._bot.loop.create_task(func.update_user(track.requester.id, {
                     "$push": {"history": {"$each": [track.track_id], "$slice": -25}}
                 }))
-                
+
         if self.settings.get('controller', True):
             await self.invoke_controller()
             
@@ -553,9 +547,10 @@ class Player(VoiceProtocol):
         tracks: List[Track] = []
 
         _duplicate_tracks = () if self.queue._allow_duplicate and duplicate else (track.uri for track in self.queue._queue)
-
+        raw_tracks = raw_tracks[0] if isinstance(raw_tracks, List) and len(raw_tracks) == 1 else raw_tracks
+        
         try:
-            if (isList := isinstance(raw_tracks, List)):
+            if (is_list := isinstance(raw_tracks, List)):
                 for track in raw_tracks:
                     if track.uri in _duplicate_tracks:
                         continue
@@ -571,11 +566,22 @@ class Player(VoiceProtocol):
         finally:
             if tracks:
                 if self.is_ipc_connected:
-                    await self.send_ws({"op": "addTrack", "tracks": [track.track_id for track in tracks]}, tracks[0].requester)
+                    await self.send_ws({"op": "addTrack", "tracks": [track.track_id for track in tracks], "position": -1 if is_list else position}, tracks[0].requester)
 
                 self._logger.debug(f"Player in {self.guild.name}({self.guild.id}) has been added {len(tracks)} tracks into the queue.")
-                return len(tracks) if isList else position
+                return len(tracks) if is_list else position
-        
+    
+    async def remove_track(self, index: int, index2: int = None, remove_target: Member = None, requester: Member = None) -> Dict[int, Track]:
+        removed_tracks = self.queue.remove(index, index2, remove_target)
+        if removed_tracks and self.is_ipc_connected:
+            await self.send_ws({
+                "op": "removeTrack",
+                "indexes": list(removed_tracks.keys()),
+                "first_track_id": list(removed_tracks.values())[0].track_id
+            }, requester=requester)
+
+        return removed_tracks
+    
     async def seek(self, position: float, requester: Member = None) -> float:
         """Seeks to a position in the currently playing track milliseconds"""
         if position < 0 or position > self._current.original.length:
@@ -628,6 +634,24 @@ class Player(VoiceProtocol):
         
         self._logger.debug(f"Player in {self.guild.name}({self.guild.id}) has been shuffled the queue.")
 
+    async def swap_track(self, index1: int, index2: int, requester: Member = None) -> Tuple[Track, Track]:
+       track1, track2 = self.queue.swap(index1, index2)
+       if self.is_ipc_connected:
+           await self.send_ws({
+                "op": "swapTrack",
+                "index1": {"index": index1, "trackId": track1.track_id},
+                "index2": {"index": index2, "trackId": track2.track_id}
+            }, requester)
+       return track1, track2
+
+    async def move_track(self, index: int, new_index: int, requester: Member = None) -> Optional[Track]:
+        moved_track = self.queue.move(index, new_index)
+
+        if self.is_ipc_connected:
+            await self.send_ws({"op": "moveTrack", "movedTrack": {"index": index, "trackId": moved_track.track_id}, "newIndex": new_index}, requester)
+
+        return moved_track
+    
     async def set_repeat(self, mode: str = None) -> str:
         if not mode:
             mode = self.queue._repeat.next().name