Réécriture complète en Typescript

src/utilsPlayer/buttons.ts

@@ -0,0 +1 @@
+export default ['loop', 'pause', 'previous', 'resume', 'shuffle', 'skip', 'stop', 'volume_down', 'volume_up']

src/utilsPlayer/disco.ts

@@ -0,0 +1,40 @@
+import { Client, TextChannel } from 'discord.js'
+import { useQueue } from 'discord-player'
+import getUptime from '../utils/getUptime'
+import writeEnv from '../utils/writeEnv'
+import generate from './generate'
+
+export default async (client: Client) => {
+		let guild = client.guilds.cache.get(process.env.DISCORD_GUILD_ID as string)
+		if (!guild) {
+			clearInterval(client.disco.interval)
+			console.log(`Aucun serveur trouvé avec l'id \`${process.env.DISCORD_GUILD_ID}\`, veuillez utiliser la commande \`/setchannel\` !`)
+			return 'clear'
+		}
+
+		// Keep track of the music progress if the bot reboots
+		let queue = useQueue(guild.id)
+		if (queue) if (queue.isPlaying()) writeEnv('DISCORD_MUSIC_CURRENT_PROGRESS', queue.node.playbackTime.toString())
+
+		let channel = client.channels.cache.get(process.env.DISCORD_PLAYERCHANNEL_ID as string) as TextChannel
+		if (!channel) {
+			clearInterval(client.disco.interval)
+			console.log(`Aucun channel trouvé avec l'id \`${process.env.DISCORD_PLAYERCHANNEL_ID}\`, veuillez utiliser la commande \`/setchannel\` !`)
+			return 'clear'
+		}
+
+		let { embed, components } = await generate(guild)
+		if (components && embed.data.footer) embed.setFooter({ text: `Uptime: ${getUptime(client.uptime)} \n ${embed.data.footer.text}` })
+		else embed.setFooter({ text: `Uptime: ${getUptime(client.uptime)}` })
+
+		let messages = await channel.messages.fetch()
+		messages.forEach(msg => { if (msg.member) if (!msg.author.bot && !msg.member.roles.cache.has(process.env.DISCORD_ROLE_ID as string)) msg.delete() })
+		
+		let botMessage = messages.find(msg => client.user && msg.author.id === client.user.id)
+		if (botMessage) {
+			if (!components && botMessage.components.length > 0) {
+				await botMessage.delete()
+				return channel.send({ embeds: [embed] })
+			} else if (components) return botMessage.edit({ embeds: [embed], components })
+		} else return channel.send({ embeds: [embed] })
+}

src/utilsPlayer/edit.ts

@@ -0,0 +1,13 @@
+import { ButtonInteraction } from 'discord.js'
+import generatePlayer from './generate'
+
+export default async (interaction: ButtonInteraction) => {
+	let guild = interaction.guild
+	if (!guild) return await interaction.reply({ content: 'Cette commande n\'est pas disponible en message privé.', ephemeral: true })
+
+	let { components } = await generatePlayer(guild)
+	if (!components) return
+
+	components.forEach((actionRow) => actionRow.components.forEach((button) => button.setDisabled(true)))
+	await interaction.update({ components })
+}

src/utilsPlayer/generate.ts

@@ -0,0 +1,76 @@
+import { EmbedBuilder, ButtonBuilder, ActionRowBuilder, Guild } from 'discord.js'
+import { useQueue } from 'discord-player'
+
+export default async (guild: Guild) => {
+	let embed = new EmbedBuilder().setColor('#ffc370')
+
+	let queue = useQueue(guild.id)
+	if (!queue) {
+		embed.setTitle('Aucune session d\'écoute en cours !')
+		return ({ embed, components: null })
+	}
+
+	let track = queue.currentTrack
+	if (!track) {
+		embed.setTitle('Aucune musique en cours de lecture !')
+		return ({ embed, components: null })
+	}
+
+	embed.setTitle(track.title)
+		.setAuthor({ name: track.author })
+		.setURL(track.url)
+		.setImage(track.thumbnail)
+		.addFields(
+			{ name: 'Durée', value: track.duration, inline: true },
+			{ name: 'Source', value: track.source === 'youtube' ? 'Youtube' : track.source === 'spotify' ? 'Spotify' : 'Inconnu', inline: true },
+			{ name: 'Volume', value: `${queue.node.volume}%`, inline: true },
+			{ name: queue.node.isPaused() ? 'Progression (en pause)' : 'Progression', value: queue.node.createProgressBar() || 'Aucune' },
+			{ name: 'Loop', value: queue.repeatMode === 3 ? 'Autoplay' : queue.repeatMode === 2 ? 'File d\'Attente' : queue.repeatMode === 1 ? 'Titre' : 'Off', inline: true }
+		)
+		.setDescription(`**Musique suivante :** ${queue.tracks.data[0] ? queue.tracks.data[0].title : 'Aucune'}`)
+		.setFooter({ text: `Demandé par ${track.requestedBy ? track.requestedBy.tag : 'Inconnu'}` })
+
+	let components = [
+		new ActionRowBuilder<ButtonBuilder>().addComponents(
+			new ButtonBuilder()
+				.setLabel(queue.node.isPaused() ? '▶️' : '⏸️')
+				.setStyle(2)
+				.setCustomId(queue.node.isPaused() ? 'resume' : 'pause'),
+			new ButtonBuilder()
+				.setLabel('⏹️')
+				.setStyle(2)
+				.setCustomId('stop'),
+			new ButtonBuilder()
+				.setLabel('⏭️')
+				.setStyle(2)
+				.setCustomId('skip')
+				.setDisabled(queue.tracks.data.length !== 0),
+			new ButtonBuilder()	
+				.setLabel('🔉')
+				.setStyle(2)
+				.setCustomId('volume_down')
+				.setDisabled(queue.node.volume === 0),
+			new ButtonBuilder()
+				.setLabel('🔊')
+				.setStyle(2)
+				.setCustomId('volume_up')
+				.setDisabled(queue.node.volume === 100)
+		),
+		new ActionRowBuilder<ButtonBuilder>().addComponents(
+			new ButtonBuilder()
+				.setLabel('🔀')
+				.setStyle(2)
+				.setCustomId('shuffle'),
+			new ButtonBuilder()
+				.setLabel('🔁')
+				.setStyle(2)
+				.setCustomId('loop'),
+			new ButtonBuilder()
+				.setLabel('⏮️')
+				.setStyle(2)
+				.setCustomId('previous')
+				.setDisabled(queue.history.previousTrack ? false : true)
+		)
+	]
+	return ({ embed, components })
+}

src/utilsPlayer/metadata.ts

@@ -0,0 +1,24 @@
+import { CommandInteraction, Guild, GuildChannel, TextBasedChannel, VoiceChannel } from 'discord.js'
+  
+type ChannelInferrable = {
+	channel: TextBasedChannel | VoiceChannel
+	guild?: Guild
+}
+
+export class PlayerMetadata {
+	public constructor(public data: ChannelInferrable) {
+		if (data.channel.isDMBased()) { throw new Error('PlayerMetadata cannot be created from a DM') }
+		if (!data.channel) { throw new Error('PlayerMetadata can only be created from a channel') }
+	}
+	public get channel() { return this.data.channel! }
+	public get guild() { return this.data.guild || (this.data.channel as GuildChannel).guild }
+
+	public static create(data: ChannelInferrable | CommandInteraction) {
+		if (data instanceof CommandInteraction) {
+			if (!data.inGuild()) { throw new Error('PlayerMetadata cannot be created from a DM') }	
+
+			return new PlayerMetadata({ channel: data.channel!, guild: data.guild! })
+		}
+		return new PlayerMetadata(data);
+	}
+}

src/utilsPlayer/replay.ts

@@ -0,0 +1,42 @@
+import { Client, TextChannel, VoiceChannel } from 'discord.js'
+import { useMainPlayer } from 'discord-player'
+
+export default async (client: Client) => {
+	let textChannel = client.channels.cache.get(process.env.DISCORD_MUSIC_TEXTCHANNEL_ID as string) as TextChannel
+	if (!textChannel) return console.log(`Aucun channel trouvé avec l'id \`${process.env.DISCORD_MUSIC_TEXTCHANNEL_ID}\`, veuillez utiliser la commande \`/setchannel\` !`)
+	let voiceChannel = client.channels.cache.get(process.env.DISCORD_MUSIC_VOICECHANNEL_ID as string) as VoiceChannel
+	if (!voiceChannel) return console.log(`Aucun channel trouvé avec l'id \`${process.env.DISCORD_MUSIC_VOICECHANNEL_ID}\`, veuillez utiliser la commande \`/setchannel\` !`)
+
+	let player = useMainPlayer()
+	let queue = player.nodes.create(textChannel.guild, {
+		metadata: {
+			channel: textChannel,
+			client: textChannel.guild.members.me,
+			requestedBy: client.user
+		},
+		selfDeaf: true,
+		volume: 20,
+		leaveOnEmpty: true,
+		leaveOnEmptyCooldown: 30000,
+		leaveOnEnd: true,
+		leaveOnEndCooldown: 300000
+	})
+			
+	try { if (!queue.connection) await queue.connect(voiceChannel) }
+	catch (error: any) { console.error(error); await textChannel.send(`Y'a eu un problème, <@223831938346123275> ! (${error.message})`) }
+	
+	let result = await player.search(process.env.DISCORD_MUSIC_CURRENT_TRACK as string, { requestedBy: client.user || undefined })
+	if (!result.hasTracks()) await textChannel.send(`Aucune musique trouvée pour **${process.env.DISCORD_MUSIC_CURRENT_TRACK}** !`)
+	let track = result.tracks[0]
+	
+	let entry = queue.tasksQueue.acquire()
+	await entry.getTask()
+	queue.addTrack(track)
+			
+	try {
+		await queue.node.play()
+		await queue.node.seek(Number(process.env.DISCORD_MUSIC_CURRENT_PROGRESS))
+		await textChannel.send(`Relancement de la musique suite à mon redémarrage...`)
+	} catch (error: any) { console.error(error); await textChannel.send(`Y'a eu un problème, <@223831938346123275> ! (${error.message})`) }
+	finally { queue.tasksQueue.release() }
+}