Ajout du Bot

commands/Musique/join.js

@@ -0,0 +1,18 @@
+const { MESSAGES } = require("../../util/constants");
+
+module.exports.run = async (client, message, args, settings) => {
+    const { channel } = message.member.voice;
+    
+    const queueConstruct = {
+        textChannel: message.channel,
+        channel,
+        connection: null,
+        songs: [],
+        loop: false,
+        playing: true
+      };
+
+    queueConstruct.connection = await channel.join();
+};
+
+module.exports.help = MESSAGES.COMMANDS.MUSIQUE.JOIN;

commands/Musique/leave.js

@@ -0,0 +1,8 @@
+const { MESSAGES } = require("../../util/constants");
+
+module.exports.run = (client, message, args, settings) => {
+    const queue = message.client.queue.get(message.guild.id);
+    queue.connection.disconnect()
+};
+
+module.exports.help = MESSAGES.COMMANDS.MUSIQUE.LEAVE;

commands/Musique/loop.js

@@ -0,0 +1,26 @@
+const { MESSAGES } = require("../../util/constants");
+const { canModifyQueue } = require("../../util/LanBot");
+
+
+module.exports.run = (client, message, args, settings) => {
+
+    if (!canModifyQueue(message.member)) return message.channel.send('Vous devez être dans un salon vocal pour utiliser cette commande !');
+    const queue = message.client.queue.get(message.guild.id)
+    if(!queue){ return message.channel.send({
+        embed: {
+            description: `Liste d'attente vide ! merci d'utiliser la commande \`${settings.prefix}play + URL / Nom de la musique\` !`,
+            color: 'BLACK'
+        }
+    })
+    }
+
+    // toggle from false to true and reverse
+    queue.loop = !queue.loop;
+    //queue.connection.dispatcher.loop()   
+    return message.channel.send(`Le loop est maintenant ${queue.loop ? `**Actif**` : `**Inactif**`}`)
+
+
+
+};
+
+module.exports.help = MESSAGES.COMMANDS.MUSIQUE.LOOP;

commands/Musique/lyrics.js

@@ -0,0 +1,30 @@
+const { MessageEmbed } = require("discord.js");
+const lyricsFinder = require("lyrics-finder");
+const { MESSAGES } = require("../../util/constants");
+
+module.exports.run = async (client, message, args, settings) => {
+    const queue = message.client.queue.get(message.guild.id);
+    if (!queue) return message.channel.send("Aucune musique lancé !").catch(console.error);
+
+    let lyrics = null;
+    const title = queue.songs[0].title;
+
+    try {
+      lyrics = await lyricsFinder(queue.songs[0].title, "");
+      if (!lyrics) lyrics = `Pas de paroles trouvé pour ${queue.songs[0].title} ! `;
+    } catch (error) {
+      lyrics = `Pas de paroles trouvé pour ${queue.songs[0].title} ! `;
+    }
+
+    let lyricsEmbed = new MessageEmbed()
+      .setTitle(`Paroles pour ${queue.songs[0].title}`)
+      .setDescription(lyrics)
+      .setColor("GREEN")
+      .setTimestamp();
+
+    if (lyricsEmbed.description.length >= 2048)
+      lyricsEmbed.description = `${lyricsEmbed.description.substr(0, 2045)}...`;
+    return message.channel.send(lyricsEmbed).catch(console.error);
+}
+
+module.exports.help = MESSAGES.COMMANDS.MUSIQUE.LYRICS;

commands/Musique/move.js

@@ -0,0 +1,22 @@
+const { MESSAGES } = require("../../util/constants");
+const move = require("array-move");
+const { canModifyQueue } = require("../../util/LanBot");
+
+module.exports.run = (client, message, args, settings) => {
+    const queue = message.client.queue.get(message.guild.id);
+    if (!queue) return message.channel.send("Il n'y a pas de musique dans la file d'attente.").catch(console.error);
+    if (!canModifyQueue(message.member)) return;
+
+    let song = queue.songs[args[0] - 1];
+
+    queue.songs = move(queue.songs, args[0] - 1, args[1] == 1 ? 1 : args[1] - 1);
+    queue.textChannel.send(
+      ("Déplacement effectué !", {
+        author: message.author,
+        title: song.title,
+        index: args[1] == 1 ? 1 : args[1]
+      })
+    );
+};
+
+module.exports.help = MESSAGES.COMMANDS.MUSIQUE.MOVE;

commands/Musique/nowplaying.js

@@ -0,0 +1,52 @@
+const { MessageEmbed, MessageAttachment } = require("discord.js");
+const musicGif = new MessageAttachment('./assets/img/Music.gif');
+const { MESSAGES } = require("../../util/constants");
+const createBar = require("string-progressbar");
+
+module.exports.run = (client, message, args, settings) => {
+    const channel = message.member.voice.channel;
+    if (!channel) return message.channel.send('Tu dois te trouver dans un salon vocal pour utiliser cette commande');
+    let queue = message.client.queue.get(message.guild.id)
+    if(!queue) return message.channel.send({
+        embed:{
+            title: `Aucune musique n'est lancé actuellement donc merci d'utiliser la commande \`${settings.prefix}play + URL\`! `
+        }
+    })
+
+    const song = queue.songs[0];
+    const seek = (queue.connection.dispatcher.streamTime - queue.connection.dispatcher.pausedTime) / 1000;
+    const left = song.duration - seek;
+
+    let nowPlaying = new MessageEmbed()
+      .setTitle("En lecture")
+      .setDescription(`${song.title}\n${song.url}`)
+      .setColor("#F8AA2A")
+      .setAuthor(message.client.user.username)
+      //.attachFiles(musicGif)
+      //.setThumbnail('attachment://Music.gif')
+      .setThumbnail('https://tenor.com/8P2l.gif');
+      
+
+      var time = new Date(left * 1000).toISOString().substr(11, 8);
+
+    if (song.duration > 0) {
+      nowPlaying.addField(
+        "\u200b",
+        new Date(seek * 1000).toISOString().substr(11, 8) +
+          "[" +
+          createBar(song.duration == 0 ? seek : song.duration, seek, 20)[0] +
+          "]" +
+          (song.duration == 0 ? " ◉ LIVE" : new Date(song.duration * 1000).toISOString().substr(11, 8)),
+        false
+      );
+      nowPlaying.setFooter(
+        (`Temps restant : ${time}`)
+      );
+    }
+
+    return message.channel.send(nowPlaying);
+
+};
+
+module.exports.help = MESSAGES.COMMANDS.MUSIQUE.NOWPLAYING;
+

commands/Musique/pause.js

@@ -0,0 +1,19 @@
+const { MESSAGES } = require("../../util/constants");
+const { canModifyQueue } = require("../../util/LanBot");
+
+module.exports.run = (client, message, args, settings) => {
+
+    if (!canModifyQueue(message.member))return message.channel.send('Vous devez être dans un salon vocal pour utiliser cette commande !');
+    let queue = message.client.queue.get(message.guild.id)
+    if(!queue) return message.channel.send({
+        embed: {
+            description: "Impossible de mettre en pause, car aucune musique n'est lancé !"
+        }
+    })
+    if(queue.playing !== false)
+    queue.connection.dispatcher.pause()
+    message.react('⏸')
+    message.channel.send('Musique mis en pause !')
+}
+
+module.exports.help = MESSAGES.COMMANDS.MUSIQUE.PAUSE;

commands/Musique/play.js

@@ -0,0 +1,116 @@
+const { play } = require("../../Includes/play");
+const ytdl = require("ytdl-core");
+const YouTubeAPI = require("simple-youtube-api");
+const { YOUTUBE_API_KEY, DEFAULT_VOLUME } = require("../../util/LanBot");
+const youtube = new YouTubeAPI(YOUTUBE_API_KEY);
+const { MessageEmbed } = require("discord.js");
+
+
+
+const { MESSAGES } = require("../../util/constants");
+
+module.exports.run = async (client, message, args, settings) => {
+    const { channel } = message.member.voice;
+
+    const serverQueue = message.client.queue.get(message.guild.id);
+    if (!channel) return message.reply("Vous devez d'abord rejoindre un canal vocal!").catch(console.error);
+    if (serverQueue && channel !== message.guild.me.voice.channel)
+      return message
+        .reply("Vous devez être dans le même canal que {user}", { user: message.client.user })
+        .catch(console.error);
+
+    if (!channel.permissionsFor(message.client.user).has("CONNECT")) return message.channel.send("Je n'ai pas la permission de rejoindre un salon vocal !")
+    if (!channel.permissionsFor(message.client.user).has("SPEAK"))return message.channel.send("Je n'ai pas la permission Parler dans le salon vocal !")
+  
+    const search = args.join(" ");
+    const videoPattern = /^(https?:\/\/)?(www\.)?(m\.)?(youtube\.com|youtu\.?be)\/.+$/gi;
+    const playlistPattern = /^.*(list=)([^#\&\?]*).*/gi;
+    const url = args[0];
+    const urlValid = videoPattern.test(args[0]);
+
+    // Start the playlist if playlist url was provided
+    if (!videoPattern.test(args[0]) && playlistPattern.test(args[0])) {
+      return message.client.commands.get("playlist").execute(message, args);
+    };
+
+
+    const queueConstruct = {
+      textChannel: message.channel,
+      channel,
+      connection: null,
+      songs: [],
+      loop: false,
+      volume: DEFAULT_VOLUME || 100,
+      playing: true
+    };
+
+    let songInfo = null;
+    let song = null;
+
+    if (urlValid) {
+      try {
+        songInfo = await ytdl.getInfo(url);
+        song = {
+          title: songInfo.videoDetails.title,
+          url: songInfo.videoDetails.video_url,
+          duration: songInfo.videoDetails.lengthSeconds,
+          views: songInfo.videoDetails.viewCount,
+          thumbnail: songInfo.videoDetails.thumbnails[2]["url"]
+        };
+      } catch (error) {
+        console.error(error);
+        return message.reply(error.message).catch(console.error);
+      }
+    } else {
+      try {
+        const results = await youtube.searchVideos(search, 1, { part: "snippet" });
+        songInfo = await ytdl.getInfo(results[0].url);
+        song = {
+          title: songInfo.videoDetails.title,
+          url: songInfo.videoDetails.video_url,
+          duration: songInfo.videoDetails.lengthSeconds,
+          views: songInfo.videoDetails.viewCount,
+          thumbnail: songInfo.videoDetails.thumbnails[2]["url"] 
+        };
+      } catch (error) {
+        console.error(error);
+        return message.reply(error.message).catch(console.error);
+      }
+    }
+    var date = new Date(0);
+    date.setSeconds(song.duration); // specify value for SECONDS here
+    var timeString = date.toISOString().substr(11, 8);
+
+
+    if (serverQueue) {
+      serverQueue.songs.push(song);
+      let embed = new MessageEmbed()
+      .setTitle('Ajouté à la liste de lecture!')
+      .setColor('#00fff1')
+      .addField('Nom', song.title, true)
+      .setThumbnail(song.thumbnail)
+      .addField('Nombre de vues', song.views, true)
+      .addField('Demandé par', message.author, true)
+      .addField('Durée', timeString, true)
+      return serverQueue.textChannel
+        .send(embed)
+        .catch(console.error);
+    }
+
+    queueConstruct.songs.push(song);
+    message.client.queue.set(message.guild.id, queueConstruct);
+
+    try {
+      queueConstruct.connection = await channel.join();
+      await queueConstruct.connection.voice.setSelfDeaf(true);
+      play(queueConstruct.songs[0], message);
+    } catch (error) {
+      console.error(error);
+      message.client.queue.delete(message.guild.id);
+      await channel.leave();
+      return message.channel.send(`Impossible de rejoindre le channel: ${error}`).catch(console.error);
+    }
+  };
+
+  module.exports.help = MESSAGES.COMMANDS.MUSIQUE.PLAY;
+

commands/Musique/playlist.js

@@ -0,0 +1,114 @@
+const { MESSAGES } = require("../../util/constants");
+const { MessageEmbed } = require("discord.js");
+const { play } = require("../../Includes/play");
+const YouTubeAPI = require("simple-youtube-api");
+
+const {
+  YOUTUBE_API_KEY,
+  MAX_PLAYLIST_SIZE,
+  DEFAULT_VOLUME,
+} = require("../../util/LanBot");
+const youtube = new YouTubeAPI(YOUTUBE_API_KEY);
+
+
+module.exports.run = async (client, message, args, settings) => {
+  const { channel } = message.member.voice;
+    const serverQueue = message.client.queue.get(message.guild.id);
+
+    if (!channel.permissionsFor(message.client.user).has("CONNECT")) return message.channel.send("Je n'ai pas la permission de rejoindre un salon vocal !")
+    if (!channel.permissionsFor(message.client.user).has("SPEAK"))return message.channel.send("Je n'ai pas la permission Parler dans le salon vocal !")
+
+    if (serverQueue && channel !== message.guild.me.voice.channel)
+      return message
+        .reply(`Vous devez être dans le même canal que ${message.client.user}`)
+        .catch(console.error);
+
+    const search = args.join(" ");
+    const pattern = /^.*(youtu.be\/|list=)([^#\&\?]*).*/gi;
+    const url = args[0];
+    const urlValid = pattern.test(args[0]);
+
+    const queueConstruct = {
+      textChannel: message.channel,
+      channel,
+      connection: null,
+      songs: [],
+      loop: false,
+      volume: DEFAULT_VOLUME || 100,
+      playing: true
+    };
+
+    let playlist = null;
+    let videos = [];
+
+    if (urlValid) {
+      try {
+        playlist = await youtube.getPlaylist(url, { part: "snippet" });
+        videos = await playlist.getVideos(MAX_PLAYLIST_SIZE || 10, { part: "snippet" });
+      } catch (error) {
+        console.error(error);
+        return message.reply("Playlist introuvable ! 🥺 ").catch(console.error);
+      }
+    } else {
+      try {
+        const results = await youtube.searchPlaylists(search, 1, { part: "snippet" });
+        playlist = results[0];
+        videos = await playlist.getVideos(MAX_PLAYLIST_SIZE || 10, { part: "snippet" });
+      } catch (error) {
+        console.error(error);
+        return message.reply(error.message).catch(console.error);
+      }
+    }
+
+    const newSongs = videos
+      .filter((video) => video.title != "Private video" && video.title != "Deleted video")
+      .map((video) => {
+        return (song = {
+          title: video.title,
+          url: video.url,
+          duration: video.durationSeconds
+        });
+      });
+
+    serverQueue ? serverQueue.songs.push(...newSongs) : queueConstruct.songs.push(...newSongs);
+
+    let playlistEmbed = new MessageEmbed()
+      .setTitle(`${playlist.title}`)
+      .setDescription(newSongs.map((song, index) => `${index + 1}. ${song.title}`))
+      .setURL(playlist.url)
+      .setColor("#F8AA2A")
+      .setTimestamp();
+
+    if (playlistEmbed.description.length >= 2048)
+      playlistEmbed.description =
+        playlistEmbed.description.substr(0, 2007) + ("\nListe de lecture supérieure à la limite de caractères...");
+
+    message.channel.send((`${message.author} a commencé une playlist`), playlistEmbed);
+
+    if (!serverQueue) {
+      message.client.queue.set(message.guild.id, queueConstruct);
+
+      try {
+        queueConstruct.connection = await channel.join();
+        await queueConstruct.connection.voice.setSelfDeaf(true);
+        play(queueConstruct.songs[0], message);
+      } catch (error) {
+        console.error(error);
+        message.client.queue.delete(message.guild.id);
+        await channel.leave();
+        return message.channel.send(`Impossible de rejoindre le channel: ${error}`).catch(console.error);
+      }
+    }
+};
+
+module.exports.help = MESSAGES.COMMANDS.MUSIQUE.PLAYLIST;
+
+/*
+Play Pause      ⏯️
+Stop            ⏹️
+Shuffle         🔀
+Loop All        🔁
+Loop One        🔂
+
+*/
+

commands/Musique/pruning.js

@@ -0,0 +1,28 @@
+const fs = require("fs");
+const { MESSAGES } = require("../../util/constants");
+
+let config;
+
+try {
+  config = require("../../config");
+} catch (error) {
+  config = null;
+}
+
+module.exports.run = (client, message, args, settings) => {
+    if (!config) return;
+    config.PRUNING = !config.PRUNING;
+
+    fs.writeFile("../../config", JSON.stringify(config, null, 2), (err) => {
+      if (err) {
+        console.log(err);
+        return message.channel.send("Une erreur s'est produite lors de l'écriture dans le fichier.").catch(console.error);
+      }
+
+      return message.channel
+        .send(`Pruning est ${config.PRUNING ? "**ON**" : "**OFF**"}`)
+        .catch(console.error);
+    });
+};
+
+module.exports.help = MESSAGES.COMMANDS.MUSIQUE.PRUNING;

commands/Musique/queue.js

@@ -0,0 +1,88 @@
+const { MessageEmbed } = require('discord.js')
+const { MESSAGES } = require("../../util/constants");
+
+module.exports.run = async (client, message, args, settings) => {
+    const permissions = message.channel.permissionsFor(message.client.user);
+    if (!permissions.has(["MANAGE_MESSAGES", "ADD_REACTIONS"]))
+      return message.reply("Il me manque l'autorisation de gérer les messages ou d'ajouter des réactions");
+
+    const queue = message.client.queue.get(message.guild.id);
+    if (!queue) return message.channel.send("❌ **Rien ne joue sur ce serveur**");
+
+    let currentPage = 0;
+    const embeds = generateQueueEmbed(message, queue.songs);
+
+    const queueEmbed = await message.channel.send(
+      `**${("Page actuelle - ")} ${currentPage + 1}/${embeds.length}**`,
+      embeds[currentPage]
+    );
+
+    try {
+      await queueEmbed.react("⬅️");
+      await queueEmbed.react("⏹");
+      await queueEmbed.react("➡️");
+    } catch (error) {
+      console.error(error);
+      message.channel.send(error.message).catch(console.error);
+    }
+
+    const filter = (reaction, user) =>
+      ["⬅️", "⏹", "➡️"].includes(reaction.emoji.name) && message.author.id === user.id;
+    const collector = queueEmbed.createReactionCollector(filter, { time: 60000 });
+
+    collector.on("collect", async (reaction, user) => {
+      try {
+        if (reaction.emoji.name === "➡️") {
+          if (currentPage < embeds.length - 1) {
+            currentPage++;
+            queueEmbed.edit(
+              ("Page actuelle - ", { page: currentPage + 1, length: embeds.length }),
+              embeds[currentPage]
+            );
+          }
+        } else if (reaction.emoji.name === "⬅️") {
+          if (currentPage !== 0) {
+            --currentPage;
+            queueEmbed.edit(
+              ("Page actuelle - ", { page: currentPage + 1, length: embeds.length }),
+              embeds[currentPage]
+            );
+          }
+        } else {
+          collector.stop();
+          reaction.message.reactions.removeAll();
+        }
+        await reaction.users.remove(message.author.id);
+      } catch (error) {
+        console.error(error);
+        return message.channel.send(error.message).catch(console.error);
+      }
+    });
+}
+
+function generateQueueEmbed(message, queue) {
+    let embeds = [];
+    let k = 10;
+  
+    for (let i = 0; i < queue.length; i += 10) {
+      const current = queue.slice(i, k);
+      let j = i;
+      k += 10;
+  
+      const info = current.map((track) => `${++j} - [${track.title}](${track.url})`).join("\n");
+  
+      const embed = new MessageEmbed()
+        .setTitle("Song Queue\n")
+        .setThumbnail(message.guild.iconURL())
+        .setColor("#F8AA2A")
+        .setDescription(
+         (`**Morceau en cours - [${queue[0].title}](${queue[0].url})**\n\n${info}`)
+        )
+        .setTimestamp();
+      embeds.push(embed);
+    }
+  
+    return embeds;
+  }
+
+module.exports.help = MESSAGES.COMMANDS.MUSIQUE.QUEUE;

commands/Musique/radiozebre.js

@@ -0,0 +1,104 @@
+const { MESSAGES } = require("../../util/constants");
+const { MessageEmbed } = require("discord.js");
+const { play } = require("../../Includes/play");
+const YouTubeAPI = require("simple-youtube-api");
+
+const {
+  YOUTUBE_API_KEY,
+  MAX_PLAYLIST_SIZE,
+  DEFAULT_VOLUME,
+} = require("../../util/LanBot");
+const youtube = new YouTubeAPI(YOUTUBE_API_KEY);
+
+
+module.exports.run = async (client, message, args, settings) => {
+  const { channel } = message.member.voice;
+    const serverQueue = message.client.queue.get(message.guild.id);
+
+    if (!channel.permissionsFor(message.client.user).has("CONNECT")) return message.channel.send("Je n'ai pas la permission de rejoindre un salon vocal !")
+    if (!channel.permissionsFor(message.client.user).has("SPEAK"))return message.channel.send("Je n'ai pas la permission Parler dans le salon vocal !")
+
+    if (serverQueue && channel !== message.guild.me.voice.channel)
+      return message
+        .reply(`Vous devez être dans le même canal que ${message.client.user}`)
+        .catch(console.error);
+
+    const search = ("https://youtube.com/playlist?list=PLEQIc8j7Pa4SX6ixC2D6wplqzXI9Jv6el");
+    const pattern = /^.*(youtu.be\/|list=)([^#\&\?]*).*/gi;
+    const url = ("https://youtube.com/playlist?list=PLEQIc8j7Pa4SX6ixC2D6wplqzXI9Jv6el");
+    const urlValid = pattern.test("https://youtube.com/playlist?list=PLEQIc8j7Pa4SX6ixC2D6wplqzXI9Jv6el");
+
+    const queueConstruct = {
+      textChannel: message.channel,
+      channel,
+      connection: null,
+      songs: [],
+      loop: false,
+      volume: DEFAULT_VOLUME || 100,
+      playing: true
+    };
+
+    let playlist = null;
+    let videos = [];
+
+    if (urlValid) {
+      try {
+        playlist = await youtube.getPlaylist(url, { part: "snippet" });
+        videos = await playlist.getVideos(MAX_PLAYLIST_SIZE || 10, { part: "snippet" });
+      } catch (error) {
+        console.error(error);
+        return message.reply("Playlist introuvable ! 🥺 ").catch(console.error);
+      }
+    } else {
+      try {
+        const results = await youtube.searchPlaylists(search, 1, { part: "snippet" });
+        playlist = results[0];
+        videos = await playlist.getVideos(MAX_PLAYLIST_SIZE || 10, { part: "snippet" });
+      } catch (error) {
+        console.error(error);
+        return message.reply(error.message).catch(console.error);
+      }
+    }
+
+    const newSongs = videos
+      .filter((video) => video.title != "Private video" && video.title != "Deleted video")
+      .map((video) => {
+        return (song = {
+          title: video.title,
+          url: video.url,
+          duration: video.durationSeconds
+        });
+      });
+
+    serverQueue ? serverQueue.songs.push(...newSongs) : queueConstruct.songs.push(...newSongs);
+
+    let playlistEmbed = new MessageEmbed()
+      .setTitle(`${playlist.title}`)
+      .setDescription(newSongs.map((song, index) => `${index + 1}. ${song.title}`))
+      .setURL(playlist.url)
+      .setColor("#F8AA2A")
+      .setTimestamp();
+
+    if (playlistEmbed.description.length >= 2048)
+      playlistEmbed.description =
+        playlistEmbed.description.substr(0, 2007) + ("\nListe de lecture supérieure à la limite de caractères...");
+
+    message.channel.send((`${message.author} a commencé une playlist`), playlistEmbed);
+
+    if (!serverQueue) {
+      message.client.queue.set(message.guild.id, queueConstruct);
+
+      try {
+        queueConstruct.connection = await channel.join();
+        await queueConstruct.connection.voice.setSelfDeaf(true);
+        play(queueConstruct.songs[0], message);
+      } catch (error) {
+        console.error(error);
+        message.client.queue.delete(message.guild.id);
+        await channel.leave();
+        return message.channel.send(`Impossible de rejoindre le channel: ${error}`).catch(console.error);
+      }
+    }
+};
+
+module.exports.help = MESSAGES.COMMANDS.MUSIQUE.RADIOZEBRE;

commands/Musique/remove.js

@@ -0,0 +1,33 @@
+const pattern = /^[0-9]{1,2}(\s*,\s*[0-9]{1,2})*$/;
+const { MESSAGES } = require("../../util/constants");
+const { canModifyQueue } = require("../../util/LanBot");
+
+module.exports.run = (client, message, args, settings) => {
+    const queue = message.client.queue.get(message.guild.id);
+
+    if (!queue) return message.channel.send("Il n'y a pas de file d'attente.").catch(console.error);
+    if (!canModifyQueue(message.member))return message.channel.send('Vous devez être dans un salon vocal pour utiliser cette commande !');
+    
+
+    const arguments = args.join("");
+    const songs = arguments.split(",").map((arg) => parseInt(arg));
+    let removed = [];
+
+    if (pattern.test(arguments)) {
+      queue.songs = queue.songs.filter((item, index) => {
+        if (songs.find((songIndex) => songIndex - 1 === index)) removed.push(item);
+        else return true;
+      });
+
+      queue.textChannel.send(
+        `${message.author} ❌ suppression de **${removed.map((song) => song.title).join("\n")}** de la file d'attente.`
+      );
+    } else if (!isNaN(args[0]) && args[0] >= 1 && args[0] <= queue.songs.length) {
+      console.log("On a eu de la chance !");
+      return queue.textChannel.send(
+        `${message.author} ❌ suppression de **${queue.songs.splice(args[0] - 1, 1)[0].title}** de la file d'attente.`
+      );
+    }
+  };
+
+  module.exports.help = MESSAGES.COMMANDS.MUSIQUE.REMOVE;

commands/Musique/resume.js

@@ -0,0 +1,18 @@
+const { MESSAGES } = require("../../util/constants");
+const { canModifyQueue } = require("../../util/LanBot");
+
+module.exports.run = (client, message, args, settings) => {
+    if (!canModifyQueue(message.member))return message.channel.send('Vous devez être dans un salon vocal pour utiliser cette commande !');
+    let queue = message.client.queue.get(message.guild.id)
+    if(!queue) return message.channel.send({
+        embed: {
+            description: "Aucune musique actuellement en pause !"
+        }
+    })
+    if(queue.playing !== false)
+    queue.connection.dispatcher.resume()
+    message.react('▶')
+    message.channel.send('Musique relancée !')
+};
+
+module.exports.help = MESSAGES.COMMANDS.MUSIQUE.RESUME;

commands/Musique/search.js

@@ -0,0 +1,60 @@
+const { MessageEmbed } = require("discord.js");
+const YouTubeAPI = require("simple-youtube-api");
+const { YOUTUBE_API_KEY } = require("../../util/LanBot");
+const youtube = new YouTubeAPI(YOUTUBE_API_KEY);
+const { MESSAGES } = require("../../util/constants");
+
+
+module.exports.run = async (client, message, args, settings) => {
+
+
+    if (message.channel.activeCollector) return message.reply("Un collecteur de messages est déjà actif dans ce canal.");
+    if (!message.member.voice.channel)
+      return message.reply("Vous devez d'abord rejoindre un canal vocal!").catch(console.error);
+
+    const search = args.join(" ");
+
+    let resultsEmbed = new MessageEmbed()
+      .setTitle("**Répondez avec le numéro de la chanson que vous souhaitez écouter**")
+      .setDescription(`Résultat pour: ${search}`)
+      .setColor("#F8AA2A");
+
+    try {
+      const results = await youtube.searchVideos(search, 10);
+      results.map((video, index) => resultsEmbed.addField(video.shortURL, `${index + 1}. ${video.title}`));
+
+      let resultsMessage = await message.channel.send(resultsEmbed);
+
+      function filter(msg) {
+        const pattern = /^[0-9]{1,2}(\s*,\s*[0-9]{1,2})*$/;
+        return pattern.test(msg.content);
+      }
+
+      message.channel.activeCollector = true;
+      const response = await message.channel.awaitMessages(filter, { max: 1, time: 30000, errors: ["time"] });
+      const reply = response.first().content;
+
+      if (reply.includes(",")) {
+        let songs = reply.split(",").map((str) => str.trim());
+
+        for (let song of songs) {
+          await message.client.commands
+            .get("play")
+            .execute(message, [resultsEmbed.fields[parseInt(song) - 1].name]);
+        }
+      } else {
+        const choice = resultsEmbed.fields[parseInt(response.first()) - 1].name;
+        message.client.commands.get("play").execute(message, [choice]);
+      }
+
+      message.channel.activeCollector = false;
+      resultsMessage.delete().catch(console.error);
+      response.first().delete().catch(console.error);
+    } catch (error) {
+      console.error(error);
+      message.channel.activeCollector = false;
+      message.reply("lantium a encore chié sur le code ! ").catch(console.error);
+    }
+  }
+
+  module.exports.help = MESSAGES.COMMANDS.MUSIQUE.SEARCH;

commands/Musique/shuffle.js

@@ -0,0 +1,23 @@
+const { MESSAGES } = require("../../util/constants");
+const { canModifyQueue } = require("../../util/LanBot");
+
+module.exports.run = (client, message, args, settings) => {
+
+  if (!canModifyQueue(message.member))return message.channel.send('Vous devez être dans un salon vocal pour utiliser cette commande !');
+  
+  const queue = message.client.queue.get(message.guild.id)
+    if(!queue) return message.channel.send("Aucune musique dans la liste d'attente !")
+   
+    let songs = queue.songs;
+    for (let i = songs.length - 1; i > 1; i--) {
+      let j = 1 + Math.floor(Math.random() * i);
+      [songs[i], songs[j]] = [songs[j], songs[i]];
+    }
+    
+    queue.songs = songs;
+    
+    message.client.queue.set(message.guild.id, queue);
+    message.channel.send(`Lecture aléatoire de la liste de lecture 🔀`).catch(console.error);
+};
+
+module.exports.help = MESSAGES.COMMANDS.MUSIQUE.SHUFFLE;

commands/Musique/skip.js

@@ -0,0 +1,23 @@
+const { MESSAGES } = require("../../util/constants");
+const { canModifyQueue } = require("../../util/LanBot");
+
+module.exports.run = (client, message, args, settings) => {
+    
+    if (!canModifyQueue(message.member))return message.channel.send('Vous devez être dans un salon vocal pour utiliser cette commande !');
+
+    let queue = message.client.queue.get(message.guild.id)
+    if(!queue){ return message.channel.send({
+        embed: {
+            description: `Liste d'attente vide ! merci d'utiliser la commande \`${settings.prefix}play + URL / Nom de la musique\` !`,
+            color: 'BLACK'
+        }
+    })
+}
+    if(queue.songs.length !== 0) {
+        message.react('✅')
+        queue.connection.dispatcher.end('Dacodac Je passe à la suivante')
+    }
+
+};
+
+module.exports.help = MESSAGES.COMMANDS.MUSIQUE.SKIP;

commands/Musique/skipto.js

@@ -0,0 +1,33 @@
+
+const { MESSAGES } = require("../../util/constants");
+const { canModifyQueue } = require("../../util/LanBot");
+
+module.exports.run = (client, message, args, settings) => {
+
+
+    const queue = message.client.queue.get(message.guild.id);
+    if (!queue) return message.channel.send("Il n'y a pas de file d'attente.").catch(console.error);
+    if (!canModifyQueue(message.member))return message.channel.send('Vous devez être dans un salon vocal pour utiliser cette commande !');
+
+    if (args[0] > queue.songs.length)
+      return message
+        .reply(`La file d'attente contient seulement ${queue.songs.length} chansons!`)
+        .catch(console.error);
+
+    queue.playing = true;
+
+    if (queue.loop) {
+      for (let i = 0; i < args[0] - 2; i++) {
+        queue.songs.push(queue.songs.shift());
+      }
+    } else {
+      queue.songs = queue.songs.slice(args[0] - 2);
+    }
+
+    queue.connection.dispatcher.end();
+    queue.textChannel
+      .send(`${message.author} ⏭ skip ${args[0] - 1} musiques`)
+      .catch(console.error);
+  }
+
+  module.exports.help = MESSAGES.COMMANDS.MUSIQUE.SKIPTO;

commands/Musique/stop.js

@@ -0,0 +1,19 @@
+const { MESSAGES } = require("../../util/constants");
+const { canModifyQueue } = require("../../util/LanBot");
+
+module.exports.run = (client, message, args, settings) => {
+    if (!canModifyQueue(message.member))return message.channel.send('Vous devez être dans un salon vocal pour utiliser cette commande !');
+
+    let queue = message.client.queue.get(message.guild.id)
+    if(!queue) return message.channel.send({
+        embed: {
+            description: "Aucune musique de jouer, donc impossible d'utiliser la commande !",
+            color: 'BLACK'
+        }
+    })
+    message.react('✅')
+    queue.songs = []
+    queue.connection.dispatcher.end('Fin!')
+};
+
+module.exports.help = MESSAGES.COMMANDS.MUSIQUE.STOP;

commands/Musique/volume.js

@@ -0,0 +1,22 @@
+const { MESSAGES } = require("../../util/constants");
+const { canModifyQueue } = require("../../util/LanBot");
+
+module.exports.run = (client, message, args, settings) => {
+    const queue = message.client.queue.get(message.guild.id);
+
+    if (!queue) return message.reply(i18n.__("volume.errorNotQueue")).catch(console.error);
+    if (!canModifyQueue(message.member))return message.channel.send('Vous devez être dans un salon vocal pour utiliser cette commande !');
+
+
+    if (!args[0]) return message.reply(`🔊 Le volume actuelle est de: **${queue.volume}%**`).catch(console.error);
+    if (isNaN(args[0])) return message.reply("Veuillez utiliser un nombre pour régler le volume.").catch(console.error);
+    if (Number(args[0]) > 100 || Number(args[0]) < 0)
+      return message.reply("Veuillez utiliser un nombre compris entre 0 et 100.").catch(console.error);
+
+    queue.volume = args[0];
+    queue.connection.dispatcher.setVolumeLogarithmic(args[0] / 100);
+    return queue.textChannel.send(`Volume réglé sur: **${args[0]}%**`).catch(console.error);
+
+};
+
+module.exports.help = MESSAGES.COMMANDS.MUSIQUE.VOLUME;