Version 1.2.0 - Ajout des suggestions et de paramètres

CHANGELOG.html

@@ -1,4 +1,13 @@
 <div class="changelog-version changelog-actual">
+    <h2>Chopin - Version /*1.2.0*/</h2>
+    <p class="changelog-date">*_Date de sortie_*: *-07/09/2025-*</p>
+    <ul>
+        <li>/#[AJOUT][FRONTEND]#/ Suggestion de recherche, depuis Youtube</li>
+        <li>/#[FIX][FRONTEND]#/ Optimisation des bouttons, avec une modification du composant</li>
+         <li>/#[AJOUT][DISCORD]#/ Ajout de la sécurité, permettant de restreindre l'utilisation du Bot au Rôle paramétré</li>
+    </ul>
+</div>  
+<div class="changelog-version">
     <h2>Chopin - Version /*1.1.0*/</h2>
     <p class="changelog-date">*_Date de sortie_*: *-06/09/2025-*</p>
     <ul>

package.json

@@ -1,6 +1,6 @@
 {
   "name": "chopin-backend",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "Discord Bot for music - Fetching everywhere !",
   "main": "src/main.js",
   "nodemonConfig": {

src/discord/Bot.js

@@ -7,6 +7,8 @@ const config = require("../utils/Database/Configuration")
 const metric = require("webmetrik") 
 const { Player } = require("../player/Player")
 const {refreshAllUserInformation} = require("../server/auth/User")
+const serverSettings = require("./ServerSettings")
+const { Embed, EmbedError } = require("./Embed")
 
 const dlog = new LogType("Discord")
 const glog = new LogType("GuildUpdater")
@@ -49,6 +51,29 @@ function getGuildMembers(guildId) {
     return guild.members.cache.map(member => member.user.id)
 }
 
+function getGuildMember(guildId, memberId) {
+    const guild = client.guilds.cache.get(guildId)
+    if(!guild) {
+        dlog.error("Guild not found: " + guildId)
+        return null
+    }
+    return guild.members.cache.get(memberId) || null
+}
+
+function getGuildRoles(guildId) {
+    const guild = client.guilds.cache.get(guildId)
+    if(!guild) {
+        dlog.error("Guild not found: " + guildId)
+        return []
+    }
+    return guild.roles.cache.map(role => ({
+        id: role.id,
+        name: role.name,
+        color: role.color,
+        position: role.position
+    }))
+}
+
 function getChannel(guildId, channelId) {
     return client.guilds.cache.get(guildId).channels.cache.get(channelId)
 }
@@ -77,7 +102,7 @@ function init() {
     operational = true
 })
 
-    client.on("interactionCreate", (interaction) => {
+    client.on("interactionCreate", async (interaction) => {
         
         if(!interaction.isCommand()) return;
 
@@ -87,13 +112,27 @@ function init() {
         numberOfCommandsServer.setValue(numberOfCommandsServer.getValue() + 1)
 
         const command = client.commands.get(interaction.commandName)
+        const roleProtected = await serverSettings.getSecureRole(interaction.guild.id) || false
+        var havePermission = true;
+        if(roleProtected) {
+            await interaction.member.fetch()
+            if(!interaction.member.roles.cache.has(roleProtected.id)) {
+                havePermission = false;
+            }
+        }
 
         try {
             // Create a metric to count the number of commands executed by each user
             const userCommand = new metric.Metric("userCommand_" + interaction.member.user.username, "Nombre de commandes éxécutées par l'utilisateur : " + interaction.member.user.username)
             userCommand.setValue(userCommand.getValue() + 1)
             dlog.log(interaction.member.user.username + "-> /" + interaction.commandName)
-            command.execute(client, interaction)
+            if(havePermission) {
+                 command.execute(client, interaction)
+            } else {
+                const embed = new EmbedError(`L'utilisation du Bot est réservée aux membres ayant le rôle "${roleProtected.name}"`, interaction, true)
+                embed.setTitle("Accès refusé")
+                embed.send()
+            }
         } catch(error) {
 
             dlog.error(interaction.member.user.username + "-> /" + interaction.commandName + " : ERREUR RENCONTRE")
@@ -219,6 +258,6 @@ function checkRequiredPermission(guildMember) {
     return requiredPermissions.filter(permission => !guildMember.permissions.has(permission));
 }
 
-module.exports = {init, getClient, getGuilds, getMembersVoices, getChannel, getGuildMembers, isReady}
+module.exports = {init, getClient, getGuilds, getMembersVoices, getChannel, getGuildMembers, getGuildMember, isReady, getGuildRoles}
 
 

src/discord/ServerSettings.js

@@ -0,0 +1,38 @@
+const { LogType } = require('loguix');
+const clog = new LogType('ServerSettings');
+const { __glob } = require('../utils/GlobalVars');
+const { Database } = require('../utils/Database/Database');
+const ServerDB = new Database("server_settings", __glob.SERVER_DB, {});
+
+function getSecureRole(guildId) {
+    checkKey(guildId);
+    var role = ServerDB.getData()[guildId].secureRole || null;
+    if(role) {
+        if(role.name === "@everyone") {
+            return null;
+        }
+    }
+    return role;
+}
+
+function setSecureRole(guildId, roleId) {
+    checkKey(guildId);
+    ServerDB.getData()[guildId].secureRole = roleId;
+    ServerDB.save();
+    process.emit("USERS_UPDATE")
+    return true;
+}
+
+async function checkKey(guildId) {
+    const data = ServerDB.getData();
+    if (!data[guildId]) {
+        data[guildId] = { secureRole: null };
+        ServerDB.save();
+    }
+   
+}
+
+module.exports = {
+    getSecureRole,
+    setSecureRole
+};

src/player/Player.js

@@ -127,7 +127,7 @@ class Player {
 
     checkConnection() {
         if(this.connection === null) {
-            clog.error(`GUILD : ${this.guildId} - La connection n'est pas définie`)
+           // clog.error(`GUILD : ${this.guildId} - La connection n'est pas définie`)
             return true
         }
         if(this.player === null) {

src/server/Server.js

@@ -19,6 +19,7 @@ const {__glob} = require("../utils/GlobalVars")
 const playlists = require("../playlists/PlaylistManager")
 const history = require("../playlists/History")
 const lyrics = require("../lyrics/Lyrics")
+const serverSettings = require("../discord/ServerSettings")
 const mediaBase = require("../discord/MediaBase")
 const googleApis = require("../playlists/Google/OAuth2")
 const youtubeApi = require("../playlists/Google/YoutubeList")
@@ -34,8 +35,6 @@ const allConnectedUsers = new Array()
 const guildConnectedUsers = new Map()
 const UsersBySocket = new Map()
 
-//TODO: Separate all request in separate files
-
 function init() {
     
     wlog.step.init("server_init", "Initialisation du serveur Socket.IO")
@@ -793,7 +792,36 @@ function init() {
                 IOAnswer("/OWNER/USERS/SWITCH_MOD", true)
             })
 
-            
+            IORequest("/OWNER/ROLES/GET", async () => {
+                if(!actualGuildId) return IOAnswer("/OWNER/ROLES/GET", false)
+                const guild = discordBot.getGuilds().get(actualGuildId)
+                if(!socketUser.identity.id === guild.owner) return IOAnswer("/OWNER/ROLES/GET", false)
+                const rolesSecure = discordBot.getGuildRoles(actualGuildId)
+                const actualRole = await serverSettings.getSecureRole(actualGuildId)
+                // Move the actual role at the start of the array
+                if(actualRole) {
+                    const index = rolesSecure.findIndex(r => r.id === actualRole.id)
+                    if(index > -1) {
+                        rolesSecure.unshift(rolesSecure.splice(index, 1)[0])
+                    }
+                } else {
+                    // Find the @everyone role and put it at the start of the array
+                    const index = rolesSecure.findIndex(r => r.name === "@everyone")
+                    if(index > -1) {
+                        rolesSecure.unshift(rolesSecure.splice(index, 1)[0])
+                    }
+                }
+                IOAnswer("/OWNER/ROLES/GET", await rolesSecure)
+            })
+
+            IORequest("/OWNER/ROLES/SET", async (data) => {
+                if(!actualGuildId) return IOAnswer("/OWNER/ROLES/SET", false)
+                const guild = discordBot.getGuilds().get(actualGuildId)
+                if(!socketUser.identity.id === guild.owner) return IOAnswer("/OWNER/ROLES/SET", false)
+                await serverSettings.setSecureRole(actualGuildId, data)
+                IOAnswer("/OWNER/ROLES/SET", true)
+            })
+
             // CHECKED : 24/04/2025
             IORequest("/MOD/USERS/BAN", async (userId) => {
                 if(!userId || !actualGuildId) return IOAnswer("/MOD/USERS/BAN", false)
@@ -907,6 +935,18 @@ function init() {
                        const guildData = guild[1]
                        guildData['members'] = new Array()
                        guildData.serverMember = guild[1].allMembers.length
+                       guildData.restricted = false
+                       const secureRole = serverSettings.getSecureRole(guild[0])
+                       if(secureRole && socketUser.identity.id !== discordBot.getGuilds().get(guild[0]).owner) {
+                        const member = discordBot.getGuildMember(guild[0], socketUser.identity.id)
+                        if(!member.roles.cache.has(secureRole.id) && socketUser.identity.id !== guild[1].owner && !socketUser.isAdmin()) {
+                            guildData.restricted = true
+                        } else {
+                            guildData.restricted = false
+                        }
+                       }
+
+                       guildData.allowed = true
                        for(var user of guildConnectedUsers.get(guild[0]) || []) {
                         const userData = users.getUserById(user.id)
                             if(userData && userData.identity.id != socketUser.identity.id) {
@@ -986,6 +1026,15 @@ function init() {
                     wlog.warn("Aucun guildId n'est actif pour l'utilisateur : " + socketUser.identity.username)
                     return false
                 }
+                // Check role if secure role is set
+                const secureRole = serverSettings.getSecureRole(guildId)
+                if(secureRole && socketUser.identity.id !== discordBot.getGuilds().get(guildId).owner) {
+                    const member = discordBot.getGuildMember(guildId, socketUser.identity.id)
+                    if(member.roles.cache.has(secureRole.id) == false) {
+                        wlog.warn("L'utilisateur '" + socketUser.identity.username + "' n'a pas le rôle requis pour accéder à la guilde : " + guildId)
+                        return false
+                    }
+                }
                 // Check if the guildId is referenced in the bot guilds 
                 if(!discordBot.getGuilds().has(guildId)) {
                     wlog.warn("La guilde : " + guildId + " n'est pas référencée dans le bot")

src/utils/GlobalVars.js

@@ -15,6 +15,7 @@ const __glob = {
     PLAYLISTFILE: root + path.sep + "data" + path.sep + "playlists.json",
     HISTORY_DB: root + path.sep + "data" + path.sep + "history.json",
     MEDIA_DB: root + path.sep + "data" + path.sep + "media.json",
+    SERVER_DB: root + path.sep + "data" + path.sep + "servers.json",
     VERSION: version,
     CHANGELOG_PATH: root + path.sep + "CHANGELOG.html",
     COOKIES: root + path.sep + "data" + path.sep + "cookies.json",