async def on_voice_state_update(self, member, before, after):
# If the bot leave a voice channel
if (before.channel is not None) and (after.channel is None):
if member == self.bot.user:
player = self.bot.wavelink.get_player(before.channel.guild.id)
if player.is_playing:
await player.destroy()
DBQueue(self.bot.dbConnection).clear(before.channel.guild.id)
DBServer(self.bot.dbConnection).clearMusicParameters(
before.channel.guild.id, False, False)
if (before.channel is not None) and (after.channel
is not before.channel):
if ((self.bot.user.id in before.channel.voice_states.keys()
and len(before.channel.voice_states) == 1)
or (member == self.bot.user)):
if member != self.bot.user:
player = self.bot.wavelink.get_player(
before.channel.guild.id)
await player.disconnect()
DBServer(self.bot.dbConnection).clearMusicParameters(
before.channel.guild.id, False, False)
# If the bot join a voice channel
elif (before.channel is None) and (after.channel is not None):
if member == self.bot.user:
DBServer(self.bot.dbConnection).clearMusicParameters(
after.channel.guild.id, False, False)
async def loopqueue(self, ctx):
if not await Check().userInVoiceChannel(ctx, self.bot): return
if not await Check().botInVoiceChannel(ctx, self.bot): return
if not await Check().userAndBotInSameVoiceChannel(ctx, self.bot): return
isLoopQueue = DBServer(self.bot.dbConnection).displayServer(ctx.guild.id)[3]
if isLoopQueue == 1:
DBServer(self.bot.dbConnection).updateLoopQueue(ctx.guild.id, False)
await ctx.channel.send(f"{ctx.author.mention} The loop queue mode was disabled!")
else:
DBServer(self.bot.dbConnection).updateLoopQueue(ctx.guild.id, True)
await ctx.channel.send(f"{ctx.author.mention} The loop queue mode was enabled!")
async def on_ready():
await bot.change_presence(activity=discord.Activity(
type=discord.ActivityType.watching, name=f"{bot.command_prefix}help"))
# Check if each server is in the DB
print("Database check")
servers = DBServer(bot.dbConnection).display()
servers = DBServer(bot.dbConnection).display()
serversId = [int(i[0]) for i in servers]
for guild in bot.guilds:
if guild.id not in serversId:
DBServer(bot.dbConnection).add(guild.id, "?", False, False, "")
print(f"* {guild.name} ({guild.id}) added")
print("----------------------------")
print(f'We have logged in as {bot.user}')
print(discord.__version__)
async def on_guild_remove(self, guild):
DBServer(self.bot.dbConnection).remove(guild.id)
# Print the log on the support server
channel = self.bot.get_channel(799998669926563860)
if channel is not None:
await channel.send(
f":red_circle: Left a server: {guild.name} ({guild.id})")
async def on_guild_join(self, guild):
DBServer(self.bot.dbConnection).add(guild.id, "?", False, False, "")
# Print the log on the support server
channel = self.bot.get_channel(799998669926563860)
if channel is not None:
await channel.send(
f":green_circle: Joined a server: {guild.name} ({guild.id})")
async def sendPlayingSongEmbed(self, channel, track):
player = self.bot.wavelink.get_player(channel.guild.id)
# Volume
volume = player.volume
# Track duration
trackDuration = await Utils().durationFormat(track.duration)
# Queue size and duration
queueSizeAndDuration = DBQueue(self.bot.dbConnection).queueSizeAndDuration(channel.guild.id)
if queueSizeAndDuration:
queueDuration = int(queueSizeAndDuration[0])
queueDuration = await Utils().durationFormat(queueDuration)
queueSize = queueSizeAndDuration[1]
else:
queueSize = 0
queueDuration = "00:00"
# Title
trackTitle = track.title.replace("*", "\\*")
# Loop and LoopQueue
isLoop = str(DBServer(self.bot.dbConnection).displayServer(channel.guild.id)[2])
isLoopQueue = str(DBServer(self.bot.dbConnection).displayServer(channel.guild.id)[3])
# Embed
embed=discord.Embed(title="Playing Song :", description=f"**[{trackTitle}]({track.uri})**", color=discord.Colour.random())
if track.thumb:
embed.set_thumbnail(url=track.thumb)
embed.add_field(name="Requested by :", value=f"`{track.requester}`", inline=True)
embed.add_field(name="Duration :", value=f"`{trackDuration}`", inline=True)
embed.add_field(name="Volume :", value=f"`{volume} %`", inline=True)
embed.add_field(name="Loop :", value=isLoop.replace("1", f"{self.bot.emojiList.true}").replace("0", f"{self.bot.emojiList.false}"), inline=True)
embed.add_field(name="Loop queue :", value=isLoopQueue.replace("1", f"{self.bot.emojiList.true}").replace("0", f"{self.bot.emojiList.false}"), inline=True)
embed.add_field(name="Lyrics :", value=f"`{self.bot.command_prefix}lyrics`", inline=True)
embed.add_field(name="Queue :", value=f"`{queueSize} song(s) ({queueDuration})`", inline=True)
embed.add_field(name="DJ Role :", value=f"`@role`", inline=True)
await channel.send(embed=embed)
async def join(self, ctx):
if not await Check().userInVoiceChannel(ctx, self.bot): return
if not await Check().botNotInVoiceChannel(ctx, self.bot): return
channel = ctx.author.voice.channel
player = self.bot.wavelink.get_player(ctx.guild.id)
await player.connect(channel.id)
# Clear all the queue
DBQueue(self.bot.dbConnection).clear(ctx.guild.id)
# Clear all server music parameters
DBServer(self.bot.dbConnection).clearMusicParameters(ctx.guild.id, False, False)
await ctx.send(f"{ctx.author.mention} Connected in **`{channel.name}`**!")
async def leave(self, ctx):
if not await Check().botInVoiceChannel(ctx, self.bot): return
if not ctx.author.guild_permissions.administrator:
if not await Check().userInVoiceChannel(ctx, self.bot): return
if not await Check().userAndBotInSameVoiceChannel(ctx, self.bot): return
player = self.bot.wavelink.get_player(ctx.guild.id)
channelId = player.channel_id
channel = self.bot.get_channel(channelId)
if player.is_playing:
await player.destroy()
await player.disconnect()
# Clear all the queue
DBQueue(self.bot.dbConnection).clear(ctx.guild.id)
# Clear all server music parameters
DBServer(self.bot.dbConnection).clearMusicParameters(ctx.guild.id, False, False)
await ctx.channel.send(f"{ctx.author.mention} Disconnected from **`{channel.name}`**!")
async def on_player_stop(self, node: wavelink.Node, payload):
serverParameters = DBServer(self.bot.dbConnection).displayServer(
payload.player.guild_id)
isLoop = serverParameters[2]
isLoopQueue = serverParameters[3]
# Clear the skip DB
DBSkip(self.bot.dbConnection).clear(payload.player.guild_id)
if isLoop == 1:
currentTrack = DBQueue(self.bot.dbConnection).getCurrentSong(
payload.player.guild_id)
requester = currentTrack[2]
channelID = currentTrack[3]
channel = self.bot.get_channel(int(channelID))
track = await self.bot.wavelink.get_tracks(currentTrack[4])
track = track[0]
await channel.send(f"🔄 Looped!")
return await playTrack(self, channel, payload.player, track,
requester)
# If not looped
track = DBQueue(self.bot.dbConnection).getNextSong(
payload.player.guild_id)
if track is None:
currentTrack = DBQueue(self.bot.dbConnection).getCurrentSong(
payload.player.guild_id)
if currentTrack:
channelID = currentTrack[3]
channel = self.bot.get_channel(int(channelID))
if channel:
await channel.send(
f"{self.bot.emojiList.false} Disconnected because the queue is empty!"
)
await payload.player.disconnect()
return
channelID = track[3]
channel = self.bot.get_channel(int(channelID))
requester = track[2]
track = track[4]
# Remove the former track
DBQueue(self.bot.dbConnection).removeFormer(payload.player.guild_id)
# update playing track to former track (index = 0)
DBQueue(self.bot.dbConnection).updatePlayingToFormer(
payload.player.guild_id)
# Change the new track to isPlaying
trackIndex = DBQueue(self.bot.dbConnection).getNextIndex(
payload.player.guild_id)
DBQueue(self.bot.dbConnection).setIsPlaying(payload.player.guild_id,
trackIndex)
await playTrack(self, channel, payload.player, track, requester)
if isLoopQueue == 1:
formerTrack = DBQueue(self.bot.dbConnection).displayFormer(
payload.player.guild_id)
if len(formerTrack) > 0:
futureIndex = DBQueue(self.bot.dbConnection).getFutureIndex(
payload.player.guild_id)
futureIndex += 1
title = formerTrack[5]
duration = formerTrack[6]
# Add the former track at the end of the queue
DBQueue(self.bot.dbConnection).add(payload.player.guild_id,
False, requester,
channel.id, track, title,
duration, futureIndex)
async def addTrack(self, ctx, tracks):
if not await Check().userInVoiceChannel(ctx, self.bot): return
# If there is only one track
if not isinstance(tracks, list):
tracks = [tracks]
player = self.bot.wavelink.get_player(ctx.guild.id)
if not player.is_connected:
# Clear all the queue
DBQueue(self.bot.dbConnection).clear(ctx.guild.id)
channel = ctx.author.voice.channel
await player.connect(channel.id)
await ctx.send(f"{ctx.author.mention} Connected in **`{channel.name}`**!")
playlistMessage = None
for track in tracks:
tempLink = track
if isinstance(track, str):
# Convert the link in a track
track = await self.bot.wavelink.get_tracks(track)
track = track[0]
if track is None:
return await channel.send(f"{self.bot.emojiList.false} The link `{tempLink}` is invalid!")
requester = f"{ctx.author.name}#{ctx.author.discriminator}"
# Add the requester
if player.is_playing:
queueSize = DBQueue(self.bot.dbConnection).countQueueItems(ctx.guild.id)
if queueSize >= 50:
return await ctx.channel.send(f"{self.bot.emojiList.false} {ctx.author.mention} You are over the queue limit! The limit of the queue is 50 songs.")
index = DBQueue(self.bot.dbConnection).getFutureIndex(ctx.guild.id)
if index is not None:
index += 1
# Add to the queue
DBQueue(self.bot.dbConnection).add(ctx.guild.id, False, requester, ctx.channel.id, track.uri, track.title, track.duration, index)
trackDuration = await Utils().durationFormat(track.duration)
trackTitle = track.title.replace("*", "\\*")
if len(tracks) == 1:
# Queue size and duration
queueSizeAndDuration = DBQueue(self.bot.dbConnection).queueSizeAndDuration(ctx.guild.id)
if queueSizeAndDuration:
queueDuration = int(queueSizeAndDuration[0])
queueDuration = await Utils().durationFormat(queueDuration)
queueSize = queueSizeAndDuration[1]
else:
queueSize = 0
queueDuration = "00:00"
embed=discord.Embed(title="Song added in the queue", description=f"New song added : **[{trackTitle}]({track.uri})** ({trackDuration})", color=discord.Colour.random())
embed.add_field(name="Place in the queue : ", value=f"`{queueSize}`", inline=True)
embed.add_field(name="Estimated time before playing :", value=f"`{queueDuration}`", inline=True)
embed.set_thumbnail(url=track.thumb)
await ctx.channel.send(embed=embed)
else:
# If it's a playlist => Update the same message to do not spam the channel
if playlistMessage is None:
embed=discord.Embed(title="Song added in the queue", description=f"- **[{trackTitle}]({track.uri})** ({trackDuration})", color=discord.Colour.random())
embed.set_thumbnail(url=track.thumb)
playlistMessage = await ctx.channel.send(embed=embed)
else:
# Update the message
embedEdited = discord.Embed(title="Songs added in the queue", description= playlistMessage.embeds[0].description + f"\n- **[{trackTitle}]({track.uri})** ({trackDuration})", color=discord.Colour.random())
playlistMessage.embeds[0].description = embedEdited.description
if len(playlistMessage.embeds[0].description) > 1800:
embed=discord.Embed(title="Song added in the queue", description=f"- **[{trackTitle}]({track.uri})** ({trackDuration})", color=discord.Colour.random())
embed.set_thumbnail(url=track.thumb)
playlistMessage = await ctx.channel.send(embed=embed)
else:
await playlistMessage.edit(embed=embedEdited)
else:
DBServer(self.bot.dbConnection).clearMusicParameters(ctx.guild.id, False, False)
DBQueue(self.bot.dbConnection).add(ctx.guild.id, True, requester, ctx.channel.id, track.uri, track.title, track.duration, 1) # Add to the DB
# Play the track
await playTrack(self, ctx, player, track, requester)