Update dependency org.springframework.security:spring-security-web to v5.6.3

README.md

@@ -1,7 +1,6 @@
 <p align="center"><img alt="discord" src="https://claptrapbot.com/favicon.png" width="150"/></p>
 
 # ClaptrapBot: A multifunctional Discord Bot ! 
-
 [![GitHub Release][releases-shield]][releases]
 ![Project Stage][project-stage-shield]
 [![License][license-shield]](LICENSE.md)
@@ -10,20 +9,16 @@
 ![Project Maintenance][maintenance-shield]
 
 [![Buy me a coffee][buymeacoffee-shield]][buymeacoffee]
-
 ## About 
-
 ClaptrapBot is a Discord bot. (No way! :open_mouth:)
 
 ### Features:
-
 - :notes: Music bot with a cool web control interface !
 - :bar_chart: Rank and Stats ! (Text and voice)
 - :heart_eyes: NSFW Commands ! (With a daily surprise :kissing_heart:)
 - :hammer_and_pick: Moderation commands !
 
 You can add the bot to your server from the home page: https://claptrapbot.com/
-
 ## Authors & contributors
 
 The original development is by [SebClem][Sebclem].
@@ -60,28 +55,19 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
 
+
+
+
 [license-shield]: https://img.shields.io/github/license/Sebclem/ClaptrapBot.svg
-
 [build-badge]: https://img.shields.io/github/workflow/status/Sebclem/ClaptrapBot/Build
-
 [maintenance-shield]: https://img.shields.io/maintenance/yes/2020.svg
-
 [project-stage-shield]: https://img.shields.io/badge/project%20stage-Beta-red.svg
-
 [buymeacoffee-shield]: https://www.buymeacoffee.com/assets/img/guidelines/download-assets-sm-2.svg
-
 [buymeacoffee]: https://www.buymeacoffee.com/seb6596
-
 [issue]: https://github.com/hassio-addons/addon-log-viewer/issues
-
 [releases-shield]: https://img.shields.io/github/release/Sebclem/ClaptrapBot.svg?include_prereleases
-
 [releases]: https://github.com/Sebclem/ClaptrapBot/releases
-
 [Sebclem]: https://github.com/Sebclem
-
 [alex]: https://github.com/Alexandre064
-
 [Aeka]: https://twitter.com/Le_aeka
-
 [contributors]: https://github.com/Sebclem/ClaptrapBot/graphs/contributors

build.gradle

@@ -33,6 +33,8 @@ dependencies {
     implementation 'org.codehaus.groovy:groovy-all:3.0.8'
 
 
+
+
     implementation 'com.sedmelluq:lavaplayer:1.3.77'
     implementation 'net.dv8tion:JDA:4.4.0_350'
     implementation group: 'org.json', name: 'json', version: '20210307'

src/main/java/net/Broken/BotListener.java

@@ -1,17 +1,16 @@
 package net.Broken;
 
+import net.Broken.Commands.Move;
 import net.Broken.DB.Entity.GuildPreferenceEntity;
+import net.Broken.DB.Entity.UserEntity;
 import net.Broken.DB.Repository.GuildPreferenceRepository;
-import net.Broken.Tools.AutoVoiceChannel;
-import net.Broken.Tools.EmbedMessageUtils;
+import net.Broken.DB.Repository.UserRepository;
+import net.Broken.Tools.*;
+import net.Broken.Tools.Command.CommandParser;
 import net.Broken.Tools.UserManager.Stats.UserStatsUtils;
 import net.Broken.audio.AudioM;
 import net.dv8tion.jda.api.EmbedBuilder;
-import net.dv8tion.jda.api.MessageBuilder;
-import net.dv8tion.jda.api.entities.Guild;
-import net.dv8tion.jda.api.entities.Message;
-import net.dv8tion.jda.api.entities.Role;
-import net.dv8tion.jda.api.entities.TextChannel;
+import net.dv8tion.jda.api.entities.*;
 import net.dv8tion.jda.api.events.ReadyEvent;
 import net.dv8tion.jda.api.events.guild.GuildJoinEvent;
 import net.dv8tion.jda.api.events.guild.member.GuildMemberJoinEvent;
@@ -21,13 +20,16 @@ import net.dv8tion.jda.api.events.guild.voice.GuildVoiceLeaveEvent;
 import net.dv8tion.jda.api.events.guild.voice.GuildVoiceMoveEvent;
 import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import net.dv8tion.jda.api.exceptions.InsufficientPermissionException;
 import net.dv8tion.jda.api.hooks.ListenerAdapter;
+import net.dv8tion.jda.api.managers.GuildManager;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.jetbrains.annotations.NotNull;
 import org.springframework.context.ApplicationContext;
 
 import java.awt.*;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 
@@ -36,59 +38,84 @@ import java.util.List;
  * Bot Listener
  */
 public class BotListener extends ListenerAdapter {
-    private final GuildPreferenceRepository guildPreferenceRepository;
+    private AntiSpam antispam = new AntiSpam();
+    private Moderateur modo = new Moderateur();
 
-    private final Logger logger = LogManager.getLogger();
+    private GuildPreferenceRepository guildPreferenceRepository;
+    private UserRepository userRepository;
+
+    private Logger logger = LogManager.getLogger();
 
     public BotListener() {
+
         ApplicationContext context = SpringContext.getAppContext();
         guildPreferenceRepository = (GuildPreferenceRepository) context.getBean("guildPreferenceRepository");
+        userRepository = (UserRepository) context.getBean("userRepository");
+
     }
 
     @Override
     public void onReady(ReadyEvent event) {
-        logger.info("Connection success");
+        logger.info("Connection succees");
     }
 
 
     @Override
     public void onGuildMemberJoin(GuildMemberJoinEvent event) {
+
         GuildPreferenceEntity guildPref = getPreference(event.getGuild());
+
         if (guildPref.isDefaultRole()) {
-            logger.info("[" + event.getGuild().getName() + "] : " + event.getUser().getName() + " join the guild, adding default role !");
-            Role default_role = event.getGuild().getRoleById(guildPref.getDefaultRoleId());
-            if (default_role != null) {
-                event.getGuild().addRoleToMember(event.getMember(), default_role).queue();
-            } else {
-                logger.fatal("[" + event.getGuild().getName() + "] : Default role is null !");
-            }
+
+            logger.info(event.getUser().getName() + "join the guild, move it!");
+
+            List<Role> roles = new ArrayList<>();
+            roles.add(event.getGuild().getRoleById(guildPref.getDefaultRoleId()));
+
+
+            new Move().exc(event.getMember(), roles, false, event.getGuild(), event.getGuild().getManager());
         }
+
+
         if (guildPref.isWelcome()) {
+
             TextChannel chanel = event.getGuild().getTextChannelById(guildPref.getWelcomeChanelID());
             if (chanel != null) {
-                String message = guildPref.getWelcomeMessage().replaceAll("@name", event.getMember().getAsMention());
+                String message = guildPref.getWelcomeMessage();
+                message = message.replaceAll("@name", event.getMember().getAsMention());
                 logger.debug(message);
-                chanel.sendMessage(message).queue();
-            }else {
-                logger.fatal("[" + event.getGuild().getName() + "] : Welcome chanel is null !");
+                chanel.sendMessage(message).complete();
             }
+
+            MainBot.roleFlag = false;
         }
 
+
     }
 
     @Override
     public void onGuildMemberRoleRemove(GuildMemberRoleRemoveEvent event) {
+
         GuildPreferenceEntity guildPref = getPreference(event.getGuild());
         if (guildPref.isDefaultRole()) {
+
+            if (!MainBot.roleFlag) {
+
                 if (event.getMember().getRoles().size() == 0) {
-                logger.info("[" + event.getGuild().getName() + "] : " + event.getUser().getName() + " have no roles, reset to default !");
-                Role default_role = event.getGuild().getRoleById(guildPref.getDefaultRoleId());
-                if (default_role == null) {
-                    logger.fatal("[" + event.getGuild().getName() + "] : Default role is null !");
-                    return;
+
+                    logger.info(event.getUser().getName() + "have no roles, move it!");
+                    List<Role> roles = new ArrayList<>();
+                    roles.add(event.getGuild().getRoleById(guildPref.getDefaultRoleId()));
+
+
+                    new Move().exc(event.getMember(), roles, false, event.getGuild(), event.getGuild().getManager());
+                    MainBot.roleFlag = false;
                 }
-                event.getGuild().addRoleToMember(event.getMember(), default_role).queue();
+            } else {
+                logger.debug("ignore it");
+                MainBot.roleFlag = false;
             }
+
         }
 
 
@@ -136,9 +163,59 @@ public class BotListener extends ListenerAdapter {
 
     @Override
     public void onMessageReceived(MessageReceivedEvent event) {
+
         if (!event.getAuthor().isBot()) {
             UserStatsUtils.getINSTANCE().addMessageCount(event.getMember());
         }
+        try {
+            if (event.getMessage().getContentRaw().startsWith("//") && !event.getMessage().getAuthor().getId().equals(event.getJDA().getSelfUser().getId())) {
+                //On a detecter que c'etait une commande
+                //System.out.println(event.getMessage().getContent());
+                List<UserEntity> users = userRepository.findByJdaId(event.getAuthor().getId());
+                UserEntity user = users.size() == 0 ? null : users.get(0);
+                MainBot.handleCommand(new CommandParser().parse(event.getMessage().getContentRaw(), event), user);
+
+            } else if (!event.getMessage().getAuthor().getId().equals(event.getJDA().getSelfUser().getId())) {
+
+                if (!event.isFromType(ChannelType.PRIVATE)) {
+
+
+                    Guild serveur = event.getGuild();
+                    GuildPreferenceEntity guildPref = getPreference(serveur);
+
+                    if (!guildPref.isAntiSpam())
+                        return;
+                    try {
+                        GuildManager guildManager = serveur.getManager();
+                        Member user = event.getMember();
+
+                        // appel de la methode d'analyse de message de "Moderateur"
+                        if (event.getMessage().getContentRaw().length() > 0) {
+
+                            if (modo.analyse(user, serveur, guildManager, event) == 1) {
+                                antispam.extermine(user, serveur, guildManager, true, event);
+                            }
+                        } else if (event.getMessage().getContentRaw().length() == 0)
+                            logger.error("Image detected, ignoring it.");
+
+                    } catch (InsufficientPermissionException e) {
+                        logger.warn("Insufficient permission for guild " + e.getGuild(MainBot.jda).getName() + " Missing " + e.getPermission() + " permission.");
+                    }
+
+                }
+
+
+            }
+        } catch (Exception e) {
+            logger.catching(e);
+
+            if (event.isFromType(ChannelType.PRIVATE))
+                PrivateMessage.send(event.getAuthor(), EmbedMessageUtils.getInternalError(), logger);
+            else
+                event.getTextChannel().sendMessage(EmbedMessageUtils.getInternalError()).queue();
+        }
+
+
     }
 
     @Override
@@ -160,15 +237,14 @@ public class BotListener extends ListenerAdapter {
                 .setDescription("Allow me to introduce myself -- I am a CL4P-TP the discord bot, but my friends call me Claptrap ! Or they would, if any of them were real...\n" +
                         "\nYou can access to my web UI with: " + MainBot.url)
                 .setImage("https://i.imgur.com/Anf1Srg.gif");
-        Message message = new MessageBuilder().setEmbeds(EmbedMessageUtils.buildStandar(eb)).build();
 
         TextChannel defaultChan = event.getGuild().getDefaultChannel();
-        if (defaultChan != null && defaultChan.canTalk()) {
-            defaultChan.sendMessage(message).queue();
-        } else {
+        if (defaultChan != null && defaultChan.canTalk())
+            defaultChan.sendMessage(EmbedMessageUtils.buildStandar(eb)).queue();
+        else {
             for(TextChannel chan : event.getGuild().getTextChannels()){
                 if(chan.canTalk()){
-                    chan.sendMessage(message).queue();
+                    chan.sendMessage(EmbedMessageUtils.buildStandar(eb)).queue();
                 }
             }
         }
@@ -178,9 +254,9 @@ public class BotListener extends ListenerAdapter {
         List<GuildPreferenceEntity> guildPrefList = guildPreferenceRepository.findByGuildId(guild.getId());
         GuildPreferenceEntity guildPref;
         if (guildPrefList.isEmpty()) {
-            logger.info("[" + guild.getName() + "] : Generate default pref");
+            logger.info("Generate default pref");
             guildPref = GuildPreferenceEntity.getDefault(guild);
-            guildPref = guildPreferenceRepository.save(guildPref);
+            guildPreferenceRepository.save(guildPref);
         } else
             guildPref = guildPrefList.get(0);
         return guildPref;

src/main/java/net/Broken/Commande.java

@@ -9,7 +9,6 @@ import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
 public interface Commande {
     /**
      * Main action of command
-     *
      * @param args Command args.
      * @param event Command MessageReceivedEvent
      */
@@ -17,28 +16,24 @@ public interface Commande {
 
     /**
      * Determines if the command is usable whit private message
-     *
      * @return boolean
      */
     boolean isPrivateUsable();
 
     /**
      * Determines if the command is usable only by admin user
-     *
      * @return boolean
      */
     boolean isAdminCmd();
 
     /**
      * Determines if the command is usable only by bot level admin user
-     *
      * @return boolean
      */
     boolean isBotAdminCmd();
 
     /**
      * Determines if the command is only usable on NSFW channels
-     *
      * @return boolean
      */
     boolean isNSFW();

src/main/java/net/Broken/Commands/Cat.java

@@ -0,0 +1,73 @@
+package net.Broken.Commands;
+
+
+import net.Broken.Commande;
+import net.dv8tion.jda.api.entities.ChannelType;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import org.json.JSONObject;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.net.URLConnection;
+
+/**
+ * Command that return a random picture of cat.
+ */
+public class Cat implements Commande {
+
+    @Override
+    public void action(String[] args, MessageReceivedEvent event) {
+
+        if(!event.isFromType(ChannelType.PRIVATE))
+        {
+            try {
+                URL urlC = new URL("http://aws.random.cat/meow");
+                URLConnection yc = urlC.openConnection();
+                BufferedReader in = new BufferedReader(new InputStreamReader(
+                        yc.getInputStream(), "UTF-8"));
+                String inputLine;
+                StringBuilder a = new StringBuilder();
+                while ((inputLine = in.readLine()) != null)
+                    a.append(inputLine);
+                in.close();
+
+                JSONObject json = new JSONObject(a.toString());
+
+                event.getTextChannel().sendMessage(json.getString("file")).queue();
+
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        else
+            event.getPrivateChannel().sendMessage("\n:warning: **__This command cannot be used there !__** :warning:").queue();
+
+    }
+
+    @Override
+    public boolean isPrivateUsable() {
+        return false;
+    }
+
+    @Override
+    public boolean isAdminCmd() {
+        return false;
+    }
+
+    /**
+     * Determines if the command is usable only by bot level admin user
+     *
+     * @return boolean
+     */
+    @Override
+    public boolean isBotAdminCmd() {
+        return false;
+    }
+
+    @Override
+    public boolean isNSFW() {
+        return false;
+    }
+}

src/main/java/net/Broken/Commands/ChannelsReview.java

@@ -3,6 +3,7 @@ package net.Broken.Commands;
 import net.Broken.Commande;
 import net.Broken.Tools.EmbedMessageUtils;
 import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.MessageHistory;
 import net.dv8tion.jda.api.entities.TextChannel;
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
 import org.apache.logging.log4j.LogManager;
@@ -29,7 +30,8 @@ public class ChannelsReview implements Commande {
             } catch (ParseException e) {
                 logger.warn("Can't parse date : " + e.getMessage());
             }
-        } else {
+        }
+        else{
             SendBack(event);
         }
     }

src/main/java/net/Broken/Commands/Code.java

@@ -0,0 +1,105 @@
+package net.Broken.Commands;
+
+import groovy.lang.Binding;
+import groovy.lang.GroovyShell;
+import net.Broken.Commande;
+import net.Broken.DB.Entity.UserEntity;
+import net.Broken.DB.Repository.GuildPreferenceRepository;
+import net.Broken.DB.Repository.UserRepository;
+import net.Broken.SpringContext;
+import net.Broken.Tools.EmbedMessageUtils;
+import net.Broken.Tools.MessageTimeOut;
+import net.Broken.Tools.PrivateMessage;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.ChannelType;
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.springframework.context.ApplicationContext;
+
+import java.awt.*;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.List;
+
+public class Code implements Commande {
+
+    private UserRepository userRepository;
+    private Logger logger = LogManager.getLogger();
+
+    public Code (){
+        ApplicationContext context = SpringContext.getAppContext();
+        userRepository = (UserRepository) context.getBean("userRepository");
+    }
+
+
+    @Override
+    public void action(String[] args, MessageReceivedEvent event) {
+
+
+        StringBuilder stringBuilder = new StringBuilder();
+        for(String arg : args){
+            stringBuilder.append(arg);
+            stringBuilder.append(" ");
+        }
+
+        Binding binding = new Binding();
+        binding.setVariable("event", event);
+        GroovyShell shell = new GroovyShell(binding);
+        EmbedBuilder builder;
+        try{
+            Object value = shell.evaluate(stringBuilder.toString());
+            StringBuilder stringResult = new StringBuilder();
+
+            if(value.getClass().isArray()){
+                Object[] array = (Object[]) value;
+                for(Object obj : array){
+                    if(stringResult.length() < 1800){
+                        stringResult.append(obj.toString()).append("\n\n");
+                    }
+                    else{
+                        stringResult.append("\n...");
+                        break;
+                    }
+
+                }
+            }else{
+                stringResult.append(value.toString());
+            }
+            builder = new EmbedBuilder().setColor(Color.orange).setTitle(":hammer_pick: Compilation Successful :hammer_pick:").setDescription("```java\n" + stringResult.toString() + "```");
+        }catch (Exception ex){
+            builder = new EmbedBuilder().setColor(Color.red).setTitle(":x: Compilation Failed :x:").setDescription("```java\n" + ex.toString() + "```");
+        }
+
+
+        event.getChannel().sendMessage(builder.build()).queue();
+
+
+    }
+
+    @Override
+    public boolean isPrivateUsable() {
+        return true;
+    }
+
+    @Override
+    public boolean isAdminCmd() {
+        return true;
+    }
+
+    /**
+     * Determines if the command is usable only by bot level admin user
+     *
+     * @return boolean
+     */
+    @Override
+    public boolean isBotAdminCmd() {
+        return true;
+    }
+
+    @Override
+    public boolean isNSFW() {
+        return false;
+    }
+}

src/main/java/net/Broken/Commands/Flush.java

@@ -0,0 +1,76 @@
+package net.Broken.Commands;
+
+import net.Broken.Commande;
+import net.Broken.Tools.EmbedMessageUtils;
+import net.dv8tion.jda.api.Permission;
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.MessageChannel;
+import net.dv8tion.jda.api.entities.MessageHistory;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+
+/**
+ * Command to flush X last message on channel.
+ */
+
+public class Flush implements Commande{
+    Logger logger = LogManager.getLogger();
+
+    @Override
+    public void action(String[] args, MessageReceivedEvent event) {
+        if(args.length<1){
+            event.getTextChannel().sendMessage(EmbedMessageUtils.getFlushError("Missing argument!")).queue();
+
+        }
+        else
+        {
+            if(event.getMember().hasPermission(Permission.ADMINISTRATOR)){
+                try {
+                    int limit = Integer.parseInt(args[0]) + 1;
+                    MessageChannel chanel = event.getChannel();
+
+                    chanel.getIterableHistory().takeAsync(limit).thenAccept(chanel::purgeMessages);
+                    
+
+                }catch (NumberFormatException e){
+                    event.getTextChannel().sendMessage(EmbedMessageUtils.getFlushError("Argument unknown!")).queue();
+                }
+            }
+            else
+            {
+                event.getTextChannel().sendMessage(EmbedMessageUtils.getFlushError("You are not a supreme being, you cannot do that !")).queue();
+            }
+
+
+
+        }
+    }
+
+    @Override
+    public boolean isPrivateUsable() {
+        return false;
+    }
+
+    @Override
+    public boolean isAdminCmd() {
+        return false;
+    }
+
+    /**
+     * Determines if the command is usable only by bot level admin user
+     *
+     * @return boolean
+     */
+    @Override
+    public boolean isBotAdminCmd() {
+        return false;
+    }
+
+    @Override
+    public boolean isNSFW() {
+        return false;
+    }
+}

src/main/java/net/Broken/Commands/Help.java

@@ -0,0 +1,195 @@
+package net.Broken.Commands;
+
+import net.Broken.Commande;
+import net.Broken.MainBot;
+import net.Broken.Tools.EmbedMessageUtils;
+import net.Broken.Tools.MessageTimeOut;
+import net.Broken.Tools.PrivateMessage;
+import net.Broken.Tools.TableRenderer;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.Permission;
+import net.dv8tion.jda.api.entities.ChannelType;
+import net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.MessageEmbed;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.awt.*;
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Help Command.
+ */
+public class Help implements Commande {
+    Logger logger = LogManager.getLogger();
+    private int cellLenght = 25;
+
+    @Override
+    public void action(String[] args, MessageReceivedEvent event) {
+        if(args.length>=1)
+        {
+            String argsString = args[0];
+            //System.out.println(argsString);
+            if (MainBot.commandes.containsKey(argsString))
+            {
+
+
+                Commande cmdObj = MainBot.commandes.get(argsString);
+                if(!cmdObj.isAdminCmd() || isAdmin(event))
+                {
+                    logger.debug("Help for "+argsString+" by "+event.getAuthor().getName());
+                    MessageEmbed messageEmbed;
+                    try {
+                        messageEmbed = EmbedMessageUtils.getHelp(argsString);
+                    } catch (FileNotFoundException e) {
+                        try {
+                            messageEmbed = EmbedMessageUtils.getHelp("Default");
+                        } catch (FileNotFoundException e1) {
+                            messageEmbed = EmbedMessageUtils.getInternalError();
+                            logger.catching(e1);
+                        }
+                    }
+                    if(!event.isFromType(ChannelType.PRIVATE)) {
+                        event.getTextChannel().sendMessage(messageEmbed).queue();
+
+                    } else{
+                        PrivateMessage.send(event.getAuthor(), messageEmbed,logger);
+                    }
+                }
+                else
+                {
+                    logger.info("Help wanted for admin command, Denied!");
+                    if(!event.isFromType(ChannelType.PRIVATE)) {
+                        Message rest = event.getTextChannel().sendMessage(EmbedMessageUtils.getUnautorized()).complete();
+                        List<Message> messages = new ArrayList<Message>(){{
+                            add(rest);
+                            add(event.getMessage());
+                        }};
+                        new MessageTimeOut(messages,MainBot.messageTimeOut).start();
+
+                    } else{
+                        PrivateMessage.send(event.getAuthor(), EmbedMessageUtils.getUnautorized(), logger);
+                    }
+                }
+
+
+
+            }
+            else
+            {
+                if(!event.isFromType(ChannelType.PRIVATE)) {
+                    Message rest = event.getTextChannel().sendMessage(EmbedMessageUtils.getUnknowCommand()).complete();
+                    List<Message> messages = new ArrayList<Message>(){{
+                        add(rest);
+                        add(event.getMessage());
+                    }};
+                    new MessageTimeOut(messages,MainBot.messageTimeOut).start();
+                } else{
+                    PrivateMessage.send(event.getAuthor(),EmbedMessageUtils.getUnknowCommand(),logger);
+                }
+                logger.debug("Unknown command!");
+            }
+        }
+        else
+        {
+            TableRenderer table = new TableRenderer();
+            table.setHeader("Command","PU");
+
+            TableRenderer nsfwTable = new TableRenderer();
+            nsfwTable.setHeader("NSFW Only\u00A0", "PU");
+            List<String> noPu = new ArrayList<>();
+
+            for (Map.Entry<String, Commande> e : MainBot.commandes.entrySet()) {
+                if(!e.getValue().isAdminCmd() || isAdmin(event)){
+                    if(e.getValue().isPrivateUsable())
+                        table.addRow(e.getKey(), "XX");
+                    else if(e.getValue().isNSFW())
+                        nsfwTable.addRow(e.getKey(),"");
+                    else
+                        noPu.add(e.getKey());
+                }
+
+
+            }
+
+            for(String key : noPu)
+                table.addRow(key, "");
+
+            String txt = table.build();
+            txt += "\n\n";
+            txt += nsfwTable.build();
+
+            if(!event.isFromType(ChannelType.PRIVATE)){
+                Message rest = event.getTextChannel().sendMessage(new EmbedBuilder().setTitle("Commands sent by private message").setColor(Color.green).build()).complete();
+                new MessageTimeOut(MainBot.messageTimeOut, rest, event.getMessage()).start();
+            }
+
+
+            String role;
+            if(isAdmin(event))
+                role = "Admin";
+            else
+                role = "No Admin";
+
+            try {
+                PrivateMessage.send(event.getAuthor(), EmbedMessageUtils.getHelpList(role, txt),logger);
+            } catch (FileNotFoundException e) {
+                logger.catching(e);
+                PrivateMessage.send(event.getAuthor(), EmbedMessageUtils.getInternalError(), logger);
+
+            }
+
+
+        }
+
+
+    }
+
+    @Override
+    public boolean isPrivateUsable() {
+        return true;
+    }
+
+    @Override
+    public boolean isAdminCmd() {
+        return false;
+    }
+
+    /**
+     * Determines if the command is usable only by bot level admin user
+     *
+     * @return boolean
+     */
+    @Override
+    public boolean isBotAdminCmd() {
+        return false;
+    }
+
+    @Override
+    public boolean isNSFW() {
+        return false;
+    }
+
+
+    public boolean isAdmin(MessageReceivedEvent event){
+
+        if(event.isFromType(ChannelType.PRIVATE)){
+            List<Guild> guilds = event.getAuthor().getMutualGuilds();
+            for(Guild iterator : guilds){
+                if(iterator.getMember(event.getAuthor()).hasPermission(Permission.ADMINISTRATOR)){
+                    return true;
+                }
+
+            }
+
+        }
+        else
+            return event.getMember().hasPermission(Permission.ADMINISTRATOR);
+        return false;
+    }
+}

src/main/java/net/Broken/Commands/Invite.java

@@ -0,0 +1,43 @@
+package net.Broken.Commands;
+
+import net.Broken.Commande;
+import net.Broken.Tools.PrivateMessage;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import org.apache.logging.log4j.LogManager;
+
+public class Invite implements Commande{
+    @Override
+    public void action(String[] args, MessageReceivedEvent event) {
+        if(event.getChannelType().isGuild()){
+            event.getTextChannel().sendMessage("You can invite me whit this link:\nhttps://discordapp.com/oauth2/authorize?client_id=" + event.getJDA().getSelfUser().getId() + "&scope=bot&permissions=8").complete();
+        }
+        else {
+            PrivateMessage.send(event.getAuthor(),"You can invite me whit this link:\nhttps://discordapp.com/oauth2/authorize?client_id=" + event.getJDA().getSelfUser().getId() + "&scope=bot&permissions=8",LogManager.getLogger());
+        }
+    }
+
+    @Override
+    public boolean isPrivateUsable() {
+        return true;
+    }
+
+    @Override
+    public boolean isAdminCmd() {
+        return false;
+    }
+
+    /**
+     * Determines if the command is usable only by bot level admin user
+     *
+     * @return boolean
+     */
+    @Override
+    public boolean isBotAdminCmd() {
+        return false;
+    }
+
+    @Override
+    public boolean isNSFW() {
+        return false;
+    }
+}

src/main/java/net/Broken/Commands/ListRoles.java

@@ -0,0 +1,48 @@
+package net.Broken.Commands;
+
+import net.Broken.Commande;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.Role;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+
+import java.awt.*;
+import java.util.List;
+
+public class ListRoles implements Commande {
+    @Override
+    public void action(String[] args, MessageReceivedEvent event) {
+        List<Role> roles = event.getGuild().getRoles();
+        EmbedBuilder messageB = new EmbedBuilder();
+        for (Role role : roles){
+            messageB.addField(role.getName(),"```id: " + role.getId() + "```",false);
+        }
+
+        messageB.setColor(Color.green);
+        event.getTextChannel().sendMessage(messageB.build()).complete();
+    }
+
+    @Override
+    public boolean isPrivateUsable() {
+        return false;
+    }
+
+    @Override
+    public boolean isAdminCmd() {
+        return true;
+    }
+
+    /**
+     * Determines if the command is usable only by bot level admin user
+     *
+     * @return boolean
+     */
+    @Override
+    public boolean isBotAdminCmd() {
+        return false;
+    }
+
+    @Override
+    public boolean isNSFW() {
+        return false;
+    }
+}

src/main/java/net/Broken/Commands/Move.java

@@ -0,0 +1,203 @@
+package net.Broken.Commands;
+
+import net.Broken.Commande;
+import net.Broken.MainBot;
+import net.Broken.Tools.EmbedMessageUtils;
+import net.Broken.Tools.MessageTimeOut;
+import net.dv8tion.jda.api.entities.*;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import net.dv8tion.jda.api.exceptions.HierarchyException;
+import net.dv8tion.jda.api.managers.GuildManager;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+/**
+ * Move Command
+ */
+public class Move implements Commande {
+
+    Logger logger = LogManager.getLogger();
+    private String HELP="`//move <@user> <@Role>`\n:arrow_right:\t*Move a user to a specified role.*";
+    public List<Role> saveRoleUser;
+    public Member user;
+    public Guild serveur;
+    public GuildManager serveurManager;
+    /** Perform a move (Reset is role and add target(s) role(s)
+     *
+     * @param user User to move
+     * @param cible Complete list of new role
+     * @param reset
+     * @param serveur Guild
+     * @param serveurManager GuildManager
+     * @return success
+     */
+    public boolean exc(Member user, List<Role> cible , boolean reset, Guild serveur, GuildManager serveurManager) throws HierarchyException
+    {
+        MainBot.roleFlag = true;
+        boolean erreur = false;
+        List<Role> allRoll = serveur.getRoles();
+
+
+
+        //On recupere les roles de l'utilisateur
+
+        List<Role> roleUserList = user.getRoles();
+
+        logger.info("Roles of " + user.getEffectiveName() + ":");
+
+        //On les save
+        saveRoleUser = roleUserList;
+
+        //Ajout du role cible
+
+        //On transforme la le role a ajouter en une liste pour pouvoir l'utiliser dans modifyMemberRoles
+
+
+        //on fait ensuite les modif
+        serveur.modifyMemberRoles(user,cible).complete();
+
+        logger.info("Give " + cible + " role to " + user.getEffectiveName());
+
+        this.user=user;
+        this.serveur=serveur;
+        this.serveurManager=serveurManager;
+        return erreur;
+    }
+
+    /** Command handler
+     *
+     * @param args
+     * @param event
+     */
+    public void action(String[] args, MessageReceivedEvent event)
+    {
+        if(!event.isFromType(ChannelType.PRIVATE))
+        {
+            if(args.length>=2)
+            {
+                serveur=event.getGuild();
+                List<User> userL = event.getMessage().getMentionedUsers();
+                List<Role> roleL = event.getMessage().getMentionedRoles();
+
+                if(userL.size()<1 ||roleL.size()<1)
+                {
+                    logger.warn("Wrong mention.");
+                    Message rest = event.getTextChannel().sendMessage(EmbedMessageUtils.getMoveError("Error, please check if the user and/or the role are existing.")).complete();
+                    List<Message> messages = new ArrayList<Message>(){{
+                        add(rest);
+                        add(event.getMessage());
+                    }};
+                    new MessageTimeOut(messages,MainBot.messageTimeOut).start();
+                }
+                else
+                {
+                    user = serveur.getMember(userL.get(0));
+                    serveur=event.getGuild();
+                    logger.info("Attempting role assignement for "+user.getEffectiveName()+" to "+roleL+" by "+event.getAuthor().getName());
+
+                    logger.info("Permission granted, role assignement authorized");
+                    logger.debug("User found");
+                    try {
+                        boolean erreur=this.exc(user,roleL,true,serveur,serveur.getManager());
+                        if(erreur)
+                        {
+                            Message rest = event.getTextChannel().sendMessage(EmbedMessageUtils.getMoveError("Check the targeted role. ")).complete();
+                            List<Message> messages = new ArrayList<Message>(){{
+                                add(rest);
+                                add(event.getMessage());
+                            }};
+                            new MessageTimeOut(messages,MainBot.messageTimeOut).start();
+                        }
+                        else
+                        {
+                            StringBuilder roleStr = new StringBuilder("");
+                            boolean first = true;
+                            for( Role role : roleL)
+                            {
+                                if (!first) {
+                                    roleStr.append(", ");
+
+                                }
+                                else
+                                    first = false;
+                                roleStr.append("__");
+                                roleStr.append(role.getName());
+                                roleStr.append("__");
+                            }
+
+
+                            Message rest = event.getTextChannel().sendMessage(EmbedMessageUtils.getMoveOk("User "+user.getEffectiveName()+" as been successfully moved to "+roleStr.toString())).complete();
+                            List<Message> messages = new ArrayList<Message>(){{
+                                add(rest);
+                                add(event.getMessage());
+                            }};
+                            new MessageTimeOut(messages,MainBot.messageTimeOut).start();
+                        }
+                    }catch (HierarchyException e){
+                        Message rest = event.getTextChannel().sendMessage(EmbedMessageUtils.getMoveError("You cannot move "+user.getRoles().get(0).getAsMention())).complete();
+                        List<Message> messages = new ArrayList<Message>(){{
+                            add(rest);
+                            add(event.getMessage());
+                        }};
+                        new MessageTimeOut(messages,MainBot.messageTimeOut).start();
+                        logger.error("Hierarchy error, please move bot's role on top!");
+                    }
+
+
+
+                }
+
+            }
+            else
+            {
+                logger.warn("Missing argument.");
+                Message rest = event.getTextChannel().sendMessage(EmbedMessageUtils.getMoveError("Missing argument.")).complete();
+                List<Message> messages = new ArrayList<Message>(){{
+                    add(rest);
+                    add(event.getMessage());
+                }};
+                new MessageTimeOut(messages,MainBot.messageTimeOut).start();
+            }
+        }
+        else
+            event.getPrivateChannel().sendMessage(EmbedMessageUtils.getNoPrivate());
+
+
+
+
+
+
+
+
+    }
+
+    @Override
+    public boolean isPrivateUsable() {
+        return false;
+    }
+
+    @Override
+    public boolean isAdminCmd() {
+        return true;
+    }
+
+    /**
+     * Determines if the command is usable only by bot level admin user
+     *
+     * @return boolean
+     */
+    @Override
+    public boolean isBotAdminCmd() {
+        return false;
+    }
+
+    @Override
+    public boolean isNSFW() {
+        return false;
+    }
+}

src/main/java/net/Broken/Commands/Ordre66.java

@@ -1,8 +1,12 @@
 package net.Broken.Commands;
 
 import net.Broken.Commande;
+import net.Broken.MainBot;
+import net.Broken.Tools.MessageTimeOut;
+import net.dv8tion.jda.api.entities.ChannelType;
 import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import org.apache.logging.log4j.LogManager;
 
 public class Ordre66 implements Commande {
 

src/main/java/net/Broken/Commands/Over18/Boobs.java

@@ -13,7 +13,6 @@ public class Boobs extends NumberedCommande {
     public Boobs() {
         super(LogManager.getLogger(), "http://lesaintdesseins.fr/","-2/","featured-img","img");
     }
-
     @Override
     public String toString() {
         return "Boobs";

src/main/java/net/Broken/Commands/Over18/Madame.java

@@ -15,9 +15,9 @@ import java.io.IOException;
  */
 @NoDev
 public class Madame extends NumberedCommande {
-    public String HELP = "Yo really? Just type Madame to see some :cat:";
     Logger logger = LogManager.getLogger();
     MessageReceivedEvent event;
+    public String HELP = "Yo really? Just type Madame to see some :cat:";
 
     public Madame() {
         super(LogManager.getLogger(), "https://www.bonjourmadame.fr/page/", "/");

src/main/java/net/Broken/Commands/Over18/SM.java

@@ -0,0 +1,57 @@
+package net.Broken.Commands.Over18;
+
+import net.Broken.Commande;
+import net.Broken.Tools.FindContentOnWebPage;
+import net.Broken.Tools.Redirection;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.IOException;
+
+/**
+ * TODO Remove this
+ */
+public class SM implements Commande {
+    Logger logger = LogManager.getLogger();
+
+    @Override
+    public void action(String[] args, MessageReceivedEvent event) {
+        Redirection redirect= new Redirection();
+        try {
+            String redirectUrl = redirect.get("https://bonjourfetish.tumblr.com/random");
+            logger.debug(redirectUrl);
+            String img = FindContentOnWebPage.doYourJob(redirectUrl, "article-picture center", "img");
+            event.getTextChannel().sendMessage(img).queue();
+        } catch (IOException e) {
+            logger.warn("Redirection fail.");
+            event.getTextChannel().sendMessage(event.getAuthor().getAsMention() + "\n:warning: **__Redirection fail (5 attempt), Try again__**:warning: ").queue();
+        }
+
+    }
+
+    @Override
+    public boolean isPrivateUsable() {
+        return false;
+    }
+
+    @Override
+    public boolean isAdminCmd() {
+        return false;
+    }
+
+    /**
+     * Determines if the command is usable only by bot level admin user
+     *
+     * @return boolean
+     */
+    @Override
+    public boolean isBotAdminCmd() {
+        return false;
+    }
+
+    @Override
+    public boolean isNSFW() {
+        return true;
+    }
+}

src/main/java/net/Broken/Commands/Over18/Suicide.java

@@ -0,0 +1,86 @@
+package net.Broken.Commands.Over18;
+
+import net.Broken.Commande;
+import net.Broken.Tools.EmbedMessageUtils;
+import net.Broken.Tools.FindContentOnWebPage;
+import net.Broken.Tools.Redirection;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.IOException;
+
+public class Suicide implements Commande{
+
+    private Logger logger = LogManager.getLogger();
+
+
+    @Override
+    public void action(String[] args, MessageReceivedEvent event) {
+        Redirection redirection = new Redirection();
+
+        String base = "http://suicidegirls.tumblr.com";
+        String redirectUrl = null;
+        try {
+
+            Boolean success = false;
+            int tryCount = 0;
+            while(!success && tryCount < 10 ){
+                redirectUrl = redirection.get(base + "/random");
+
+                String img;
+                try{
+                    img = FindContentOnWebPage.doYourJob(redirectUrl, "post photo_nav_caption", "img");
+                    event.getTextChannel().sendMessage(img).queue();
+                    success = true;
+
+                }catch (StringIndexOutOfBoundsException | IOException e){
+                    logger.debug("Photo_nav not found try photoset");
+
+                    try {
+                        String mid = FindContentOnWebPage.doYourJob(redirectUrl, "html_photoset", "iframe");
+                        img = FindContentOnWebPage.doYourJob(base + mid, "photoset_row", "img");
+                        event.getTextChannel().sendMessage(img).queue();
+                        success = true;
+                    } catch (StringIndexOutOfBoundsException | IOException e1) {
+                        logger.debug("Nothing found, assume it's a comment.");
+                    }
+
+
+                }
+                tryCount ++;
+            }
+        } catch (IOException e) {
+            logger.catching(e);
+        }
+
+
+
+
+    }
+
+    @Override
+    public boolean isPrivateUsable() {
+        return false;
+    }
+
+    @Override
+    public boolean isAdminCmd() {
+        return false;
+    }
+
+    /**
+     * Determines if the command is usable only by bot level admin user
+     *
+     * @return boolean
+     */
+    @Override
+    public boolean isBotAdminCmd() {
+        return false;
+    }
+
+    @Override
+    public boolean isNSFW() {
+        return true;
+    }
+}

src/main/java/net/Broken/Commands/Ping.java

@@ -0,0 +1,54 @@
+package net.Broken.Commands;
+
+import net.Broken.Commande;
+import net.Broken.MainBot;
+import net.Broken.Tools.MessageTimeOut;
+import net.dv8tion.jda.api.entities.ChannelType;
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import org.apache.logging.log4j.LogManager;
+
+
+/**
+ * Command that return the Bot's ping
+ */
+public class Ping implements Commande {
+
+    @Override
+    public void action(String[] args, MessageReceivedEvent event) {
+        long ping = event.getJDA().getGatewayPing();
+//        long receivedTime = Timestamp.valueOf(LocalDateTime.ofInstant(event.getMessage().getCreationTime().toInstant(), ZoneId.systemDefault())).getTime();
+        if(event.isFromType(ChannelType.PRIVATE))
+            event.getPrivateChannel().sendMessage(":arrow_right: Pong! `" + ping+ "ms`").queue();
+        else {
+            Message rest = event.getTextChannel().sendMessage(event.getAuthor().getAsMention()+"\n:arrow_right: Pong! `" + ping + "ms`").complete();
+            new MessageTimeOut(MainBot.messageTimeOut, event.getMessage(), rest).start();
+        }
+        LogManager.getLogger().debug("pong");
+    }
+
+    @Override
+    public boolean isPrivateUsable() {
+        return true;
+    }
+
+    @Override
+    public boolean isAdminCmd() {
+        return false;
+    }
+
+    /**
+     * Determines if the command is usable only by bot level admin user
+     *
+     * @return boolean
+     */
+    @Override
+    public boolean isBotAdminCmd() {
+        return false;
+    }
+
+    @Override
+    public boolean isNSFW() {
+        return false;
+    }
+}

src/main/java/net/Broken/Commands/ReportUsers.java

@@ -3,8 +3,10 @@ package net.Broken.Commands;
 import net.Broken.Commande;
 import net.Broken.Tools.EmbedMessageUtils;
 import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
 import net.dv8tion.jda.api.requests.RestAction;
+import net.dv8tion.jda.api.requests.restaction.MessageAction;
 
 
 public class ReportUsers implements Commande {

src/main/java/net/Broken/Commands/Settings.java

@@ -1,17 +1,27 @@
 package net.Broken.Commands;
 
 import net.Broken.Commande;
+import net.Broken.DB.Entity.GuildPreferenceEntity;
 import net.Broken.DB.Repository.GuildPreferenceRepository;
 import net.Broken.MainBot;
 import net.Broken.SpringContext;
 import net.Broken.Tools.EmbedMessageUtils;
+import net.Broken.Tools.MessageTimeOut;
+import net.Broken.Tools.SettingsUtils;
+import net.Broken.audio.AudioM;
+import net.Broken.audio.NotConnectedException;
+import net.Broken.audio.NullMusicManager;
+import net.Broken.audio.Youtube.YoutubeTools;
 import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.*;
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.springframework.context.ApplicationContext;
 
 import java.awt.*;
+import java.io.IOException;
+import java.util.List;
 
 public class Settings implements Commande {
 

src/main/java/net/Broken/Commands/Spam.java

@@ -0,0 +1,351 @@
+package net.Broken.Commands;
+
+import net.Broken.Commande;
+import net.Broken.MainBot;
+import net.Broken.Tools.AntiSpam;
+import net.Broken.Tools.EmbedMessageUtils;
+import net.Broken.Tools.MessageTimeOut;
+import net.Broken.Tools.UserSpamUtils;
+import net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import net.dv8tion.jda.api.exceptions.RateLimitedException;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+
+/**
+ * Spam admin command
+ */
+
+// TODO Rebuild this ...
+public class Spam implements Commande {
+    private Logger logger = LogManager.getLogger();
+
+    @Override
+    public void action(String[] args, MessageReceivedEvent event)
+    {
+        /****************************
+         *   Verif argument         *
+         ****************************/
+        if(args.length>=1)
+        {
+
+            String commande = args[0];
+            /****************************
+             * on traite la commande    *
+             ****************************/
+            switch (commande) {
+
+                case "pardon":
+                    this.pardon(event,args);
+                    break;
+
+                case "extermine":
+                    try {
+                        this.extermine(event,args);
+                    } catch (RateLimitedException e) {
+                        e.printStackTrace();
+                    }
+
+                    break;
+
+                case "reset":
+                    try {
+                        this.reset(event,args);
+                    } catch (RateLimitedException e) {
+                        e.printStackTrace();
+                    }
+                    break;
+
+
+
+            }
+
+        }
+    }
+
+
+    @Override
+    public boolean isPrivateUsable() {
+        return false;
+    }
+
+    @Override
+    public boolean isAdminCmd() {
+        return true;
+    }
+
+    /**
+     * Determines if the command is usable only by bot level admin user
+     *
+     * @return boolean
+     */
+    @Override
+    public boolean isBotAdminCmd() {
+        return false;
+    }
+
+    @Override
+    public boolean isNSFW() {
+        return false;
+    }
+
+    public void pardon(MessageReceivedEvent event, String[] args){
+
+        Guild serveur = event.getGuild();
+        /****************************
+         * verif argument           *
+         ****************************/
+        if (args.length >= 1)
+        {
+            /****************************
+             * On recupere l'utilisateur et le role cible
+             ****************************/
+            List<Member> userL = event.getMessage().getMentionedMembers();
+
+
+            /****************************
+             * verif utilisteur trouver *
+             ****************************/
+            if(userL.size()<1)
+            {
+                logger.error("User unknown.");
+                Message rest = event.getTextChannel().sendMessage(EmbedMessageUtils.getSpamError(":arrow_right: User not found. ","pardon")).complete();
+                List<Message> messages = new ArrayList<Message>(){{
+                    add(rest);
+                    add(event.getMessage());
+                }};
+                new MessageTimeOut(messages,MainBot.messageTimeOut).start();
+            }
+            else {
+                Member user = userL.get(0);
+                logger.info("Attempt to forgive  " + user.getEffectiveName() + " by " + event.getMember().getEffectiveName());
+            /****************************
+                 * virif si en spammer    *
+                 ****************************/
+                if (MainBot.spamUtils.containsKey(user)) {
+                    if (MainBot.spamUtils.get(user).isOnSpam()) {
+                        MainBot.spamUtils.get(user).setOnSpam(false);
+                    } else {
+                        logger.warn("User is not in spam.");
+                        Message rest = event.getTextChannel().sendMessage(EmbedMessageUtils.getSpamError(":arrow_right: This user is not in spam.","pardon")).complete();
+                        List<Message> messages = new ArrayList<Message>(){{
+                            add(rest);
+                            add(event.getMessage());
+                        }};
+                        new MessageTimeOut(messages,MainBot.messageTimeOut).start();
+                    }
+
+
+                } else {
+                    logger.warn("User is not in spam.");
+                    Message rest = event.getTextChannel().sendMessage(EmbedMessageUtils.getSpamError(":arrow_right: This user is not in spam.","pardon")).complete();
+                    List<Message> messages = new ArrayList<Message>(){{
+                        add(rest);
+                        add(event.getMessage());
+                    }};
+                    new MessageTimeOut(messages,MainBot.messageTimeOut).start();
+                }
+            }
+        }
+        else
+        {
+            logger.warn("Missing argument.");
+            Message rest = event.getTextChannel().sendMessage(EmbedMessageUtils.getSpamError("Missing argument!","pardon")).complete();
+            List<Message> messages = new ArrayList<Message>(){{
+                add(rest);
+                add(event.getMessage());
+            }};
+            new MessageTimeOut(messages,MainBot.messageTimeOut).start();
+        }
+
+
+    }
+
+    public void extermine(MessageReceivedEvent event, String[] args) throws RateLimitedException {
+        /****************************
+         * verif argument           *
+         ****************************/
+        if (args.length >= 3)
+        {
+            /****************************
+             * On recupere l'utilisateur et le role cible
+             ****************************/
+            List<User> userL = event.getMessage().getMentionedUsers();
+
+
+            /****************************
+             * verif utilisteur trouver *
+             ****************************/
+            if(userL.size()<1)
+            {
+                logger.warn("Wrong mention (Spam).");
+                Message rest = event.getTextChannel().sendMessage(EmbedMessageUtils.getSpamError("Wrong mention. ","extermine")).complete();
+            }
+            else{
+
+
+                Guild serveur = event.getGuild();
+                Member user = serveur.getMember(userL.get(0));
+                logger.info("Starting protocol 66 on "+user.getEffectiveName()+" by the command of "+event.getAuthor().getName());
+
+
+                String multiStr =args[2];
+
+
+                /****************************
+                 * virif pas deja en spammer    *
+                 ****************************/
+                if(MainBot.spamUtils.containsKey(user))
+                {
+                    if(!MainBot.spamUtils.get(user).isOnSpam())
+                    {
+                        this.goSpam(user,multiStr,serveur,event);
+                    }
+                    else
+                    {
+                        logger.warn("User already in spam.");
+                        Message rest = event.getTextChannel().sendMessage(EmbedMessageUtils.getSpamError("User already in spam.","extermine")).complete();
+                        List<Message> messages = new ArrayList<Message>(){{
+                            add(rest);
+                            add(event.getMessage());
+                        }};
+                        new MessageTimeOut(messages,MainBot.messageTimeOut).start();
+                    }
+
+
+                }
+                else
+                {
+                    this.goSpam(user,multiStr,serveur,event);
+                }
+
+            }
+
+
+        }
+        else
+        {
+            logger.warn("Missing argument.");
+            Message rest = event.getTextChannel().sendMessage(EmbedMessageUtils.getSpamError("Missing argument!","extermine")).complete();
+            List<Message> messages = new ArrayList<Message>(){{
+                add(rest);
+                add(event.getMessage());
+            }};
+            new MessageTimeOut(messages,MainBot.messageTimeOut).start();
+        }
+    }
+
+    public void reset(MessageReceivedEvent event, String[] args) throws RateLimitedException {
+        if(event!=null)
+        {
+            if(args.length>=2)
+            {
+
+                Guild serveur = event.getGuild();
+                /****************************
+                 * On recupere l'utilisateur et le role cible
+                 ****************************/
+                List<Member> userL = event.getMessage().getMentionedMembers();
+
+
+                /****************************
+                 * verif utilisteur trouver *
+                 ****************************/
+                if(userL.size()<1)
+                {
+                    logger.warn("User not found.");
+                    Message rest = event.getTextChannel().sendMessage(EmbedMessageUtils.getSpamError("User not found.","reset")).complete();
+                    List<Message> messages = new ArrayList<Message>(){{
+                        add(rest);
+                        add(event.getMessage());
+                    }};
+                    new MessageTimeOut(messages,MainBot.messageTimeOut).start();
+
+                }
+                else {
+                    Member user = userL.get(0);
+                    logger.info("Attempt spam reset of " + user.getEffectiveName() + " by " + event.getMember().getEffectiveName());
+
+
+                    /****************************
+                     * verif utilisteur trouver *
+                     ****************************/
+                    if (MainBot.spamUtils.containsKey(user)) {
+                        logger.info("Multiplictor reset for " + user.getEffectiveName() + " done.");
+                        Message rest = event.getTextChannel().sendMessage(event.getAuthor().getAsMention() + "\n *The spam multiplicator of " + user.getEffectiveName() + " is now down to zero.*").complete();
+                        List<Message> messages = new ArrayList<Message>(){{
+                            add(rest);
+                            add(event.getMessage());
+                        }};
+                        new MessageTimeOut(messages,MainBot.messageTimeOut).start();
+                        MainBot.spamUtils.remove(user);
+
+                    }
+
+                }
+            }
+            else
+            {
+                logger.warn("Missing argument.");
+                Message rest = event.getTextChannel().sendMessage(EmbedMessageUtils.getSpamError("Missing argument!","reset")).complete();
+                List<Message> messages = new ArrayList<Message>(){{
+                    add(rest);
+                    add(event.getMessage());
+                }};
+                new MessageTimeOut(messages,MainBot.messageTimeOut).start();
+            }
+        }
+        else
+        {
+            if (args[0].equals("all"))
+            {
+                logger.info("Multiplicator reseted automaticly.");
+                for (Member unUser: MainBot.spamUtils.keySet())
+                {
+
+                    MainBot.message_compteur.remove(unUser); //TODO resolve garbage collector error ????
+                }
+            }
+        }
+
+
+
+    }
+
+
+
+
+    public void goSpam(Member user, String multiStr, Guild serveur, MessageReceivedEvent event)
+    {
+        if(Objects.equals(multiStr, "/"))
+        {
+            new AntiSpam().extermine(user,serveur,serveur.getManager(),true,event);
+
+        }
+        else
+        {
+            int multi = Integer.parseInt(multiStr);
+            if(MainBot.spamUtils.containsKey(user))
+            {
+                MainBot.spamUtils.get(user).setMultip(multi);
+            }
+            else
+            {
+                MainBot.spamUtils.put(user,new UserSpamUtils(user,new ArrayList<>()));
+                MainBot.spamUtils.get(user).setMultip(multi);
+            }
+
+            new AntiSpam().extermine(user,serveur,serveur.getManager(),false,event);
+
+        }
+    }
+}

src/main/java/net/Broken/Commands/SpamInfo.java

@@ -0,0 +1,200 @@
+package net.Broken.Commands;
+
+import net.Broken.Commande;
+import net.Broken.MainBot;
+import net.Broken.Tools.EmbedMessageUtils;
+import net.Broken.Tools.MessageTimeOut;
+import net.Broken.Tools.PrivateMessage;
+import net.Broken.Tools.UserSpamUtils;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.ChannelType;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.awt.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Spam Info Command
+ */
+public class SpamInfo implements Commande{
+    private HashMap<Member,MessageUpdater> threadHashMap = new HashMap<>();
+
+    Logger logger = LogManager.getLogger();
+
+    @Override
+    public void action(String[] args, MessageReceivedEvent event) {
+        Member user;
+        if(event.getMessage().getMentionedUsers().size() == 0){
+            user = event.getMember();
+        }
+        else {
+            user = event.getMessage().getMentionedMembers().get(0);
+        }
+
+
+        Message message = null;
+        if(!MainBot.spamUtils.containsKey(user)){
+            if(!event.isFromType(ChannelType.PRIVATE))
+                message = event.getTextChannel().sendMessage(EmbedMessageUtils.getSpamInfo(user.getEffectiveName() + ":\n\t- Multiplicator: `1`\n\t- In spam: `No`")).complete();
+            else
+                PrivateMessage.send(event.getAuthor(),EmbedMessageUtils.getSpamInfo(user.getEffectiveName()+":\n\t- Multiplicator: `1`\n\t- In spam: `No`"),logger);
+        }
+        else{
+            UserSpamUtils util = MainBot.spamUtils.get(user);
+            if(!util.isOnSpam()){
+                if(!event.isFromType(ChannelType.PRIVATE))
+                    message = event.getTextChannel().sendMessage(EmbedMessageUtils.getSpamInfo(user.getEffectiveName()+"\n\t- Multiplicator: `"+util.getMultip()+"`\n\t- In spam: `No`")).complete();
+                else
+                    PrivateMessage.send(event.getAuthor(),EmbedMessageUtils.getSpamInfo(user.getEffectiveName()+":\n\t- Multiplicator: `"+util.getMultip()+"`\n\t- In spam: `No`"),logger);
+            }
+            else{
+                if(!event.isFromType(ChannelType.PRIVATE))
+                    message = event.getTextChannel().sendMessage(EmbedMessageUtils.getSpamInfo(user.getEffectiveName()+":\n\t- Multiplicator: `"+util.getMultip()+"`\n\t- In spam: `Yes`\n\t- Time remaining: `"+formatSecond(util.getTimeLeft())+"`")).complete();
+                else
+                    message = PrivateMessage.send(event.getAuthor(),EmbedMessageUtils.getSpamInfo(user.getEffectiveName()+"\n\t- Multiplicator: `"+util.getMultip()+"`\n\t- In spam: `Yes`\n\t- Time remaining: `"+formatSecond(util.getTimeLeft())+"`"),logger);
+                }
+        }
+        if(message != null){
+            if(threadHashMap.containsKey(user)){
+                MessageUpdater startedThread = threadHashMap.get(user);
+                if(!message.getChannelType().equals(startedThread.message.getChannelType())){
+                    MessageUpdater newThread = new MessageUpdater(message,event.getMessage(),MainBot.spamUtils.get(user),user);
+                    threadHashMap.put(user,newThread);
+                    newThread.start();
+                }
+                else
+                {
+                   threadHashMap.get(user).stop = true;
+                    MessageUpdater newThread = new MessageUpdater(message,event.getMessage(),MainBot.spamUtils.get(user),user);
+                    threadHashMap.replace(user, newThread);
+                    newThread.start();
+                }
+            }
+            else
+            {
+                MessageUpdater newThread = new MessageUpdater(message,event.getMessage(),MainBot.spamUtils.get(user),user);
+                threadHashMap.put(user, newThread);
+                newThread.start();
+            }
+        }
+
+
+
+
+    }
+
+    @Override
+    public boolean isPrivateUsable() {
+        return true;
+    }
+
+    @Override
+    public boolean isAdminCmd() {
+        return false;
+    }
+
+    /**
+     * Determines if the command is usable only by bot level admin user
+     *
+     * @return boolean
+     */
+    @Override
+    public boolean isBotAdminCmd() {
+        return false;
+    }
+
+    @Override
+    public boolean isNSFW() {
+        return false;
+    }
+
+    public String formatSecond(int second){
+        long days = TimeUnit.SECONDS.toDays(second);
+        second -= TimeUnit.DAYS.toSeconds(days);
+
+        long hours = TimeUnit.SECONDS.toHours(second);
+        second -= TimeUnit.HOURS.toSeconds(hours);
+
+
+        long minutes = TimeUnit.SECONDS.toMinutes(second);
+        second -= TimeUnit.MINUTES.toSeconds(minutes);
+
+        long seconds = TimeUnit.SECONDS.toSeconds(second);
+
+        logger.debug(""+days+":"+hours+":"+minutes+":"+seconds);
+        String finalText = "";
+        if(days!=0)
+            finalText += days+" day(s) ";
+        if(hours!=0)
+            finalText += hours+"h ";
+        if(minutes!=0)
+            finalText += minutes+"min ";
+        finalText += seconds+"s";
+
+        return finalText;
+
+    }
+
+
+    private class MessageUpdater extends Thread{
+        public Message message;
+        public Message command;
+        public UserSpamUtils util;
+        public boolean stop;
+        private int oldValue;
+        private Member user;
+
+        public MessageUpdater(Message message,Message command, UserSpamUtils util, Member user) {
+            this.message = message;
+            this.util = util;
+            this.user = user;
+            this.command = command;
+
+        }
+
+        @Override
+        public void run() {
+            logger.debug("Start "+user.getEffectiveName()+" theard!");
+            if(util != null){
+                oldValue = util.getTimeLeft();
+                while (util.getTimeLeft()!=0 && !stop && util.isOnSpam()){
+                    try {
+                        Thread.sleep(500);
+                        if(util.getTimeLeft()%5 == 0 && oldValue - util.getTimeLeft() >= 5){
+                            message.editMessage(EmbedMessageUtils.getSpamInfo(user.getEffectiveName()+":\n\t- Multiplicator: `"+util.getMultip()+"`\n\t- In spam: `Yes`\n\t- Time remaining: `"+formatSecond(util.getTimeLeft())+"`")).complete();
+                            oldValue = util.getTimeLeft();
+                        }
+
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                }
+                logger.debug("Kill "+user.getEffectiveName()+" theard!");
+                if(stop)
+                    message.editMessage(new EmbedBuilder().setColor(Color.RED).setTitle("Aborted").build()).complete();
+                else
+                    message.editMessage(EmbedMessageUtils.getSpamInfo(user.getEffectiveName()+"\n\t- Multiplicator: `"+util.getMultip()+"`\n\t- In spam: `No`")).complete();
+
+            }
+            logger.debug("Timer for message deletion of "+user.getEffectiveName()+" stated...");
+            threadHashMap.remove(user);
+            List<Message> messages = new ArrayList<>();
+            messages.add(command);
+            messages.add(message);
+            new MessageTimeOut(messages,15).start();
+
+
+
+
+
+        }
+    }
+}

src/main/java/net/Broken/Commands/YtSearch.java

@@ -0,0 +1,79 @@
+package net.Broken.Commands;
+
+import com.google.api.client.googleapis.json.GoogleJsonResponseException;
+import net.Broken.Commande;
+import net.Broken.MainBot;
+import net.Broken.Tools.EmbedMessageUtils;
+import net.Broken.Tools.MessageTimeOut;
+import net.Broken.audio.Youtube.SearchResult;
+import net.Broken.audio.Youtube.YoutubeSearchRework;
+import net.Broken.audio.Youtube.YoutubeTools;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.MessageEmbed;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class YtSearch implements Commande {
+
+    private Logger logger = LogManager.getLogger();
+
+    @Override
+    public void action(String[] args, MessageReceivedEvent event) {
+
+        YoutubeSearchRework youtubeSearch = YoutubeSearchRework.getInstance();
+        if (args.length < 1) {
+            logger.info("YtSearch: Missing args, user: " + event.getAuthor().getName());
+            Message message = event.getChannel().sendMessage(EmbedMessageUtils.buildStandar(EmbedMessageUtils.getError("Missing search query!"))).complete();
+            new MessageTimeOut(MainBot.messageTimeOut, message, event.getMessage()).start();
+        } else {
+            try {
+
+                StringBuilder builder = new StringBuilder();
+                for (String arg : args) {
+                    builder.append(arg);
+                }
+                List<SearchResult> result = youtubeSearch.searchVideo(builder.toString(), 5, false);
+                for (SearchResult item : result) {
+                    event.getChannel().sendMessage(EmbedMessageUtils.searchResult(item)).queue();
+                }
+
+            } catch (IOException t) {
+                logger.catching(t);
+                event.getChannel().sendMessage(EmbedMessageUtils.getInternalError()).queue();
+            }
+        }
+
+
+    }
+
+    @Override
+    public boolean isPrivateUsable() {
+        return false;
+    }
+
+    @Override
+    public boolean isAdminCmd() {
+        return false;
+    }
+
+    /**
+     * Determines if the command is usable only by bot level admin user
+     *
+     * @return boolean
+     */
+    @Override
+    public boolean isBotAdminCmd() {
+        return false;
+    }
+
+    @Override
+    public boolean isNSFW() {
+        return false;
+    }
+}

src/main/java/net/Broken/DB/Entity/GuildPreferenceEntity.java

@@ -1,11 +1,11 @@
 package net.Broken.DB.Entity;
 
 import net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.VoiceChannel;
 
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
+import javax.persistence.*;
+import java.util.ArrayList;
+import java.util.List;
 
 @Entity
 public class GuildPreferenceEntity {

src/main/java/net/Broken/DB/Entity/PendingPwdResetEntity.java

@@ -27,8 +27,7 @@ public class PendingPwdResetEntity {
 
     }
 
-    public PendingPwdResetEntity() {
-    }
+    public PendingPwdResetEntity() {}
 
 
     public UserEntity getUserEntity() {

src/main/java/net/Broken/DB/Entity/PendingUserEntity.java

@@ -34,6 +34,7 @@ public class PendingUserEntity {
     }
 
 
+
     public String getPassword() {
         return password;
     }

src/main/java/net/Broken/DB/Entity/PlaylistEntity.java

@@ -3,7 +3,10 @@ package net.Broken.DB.Entity;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
 
+import javax.annotation.Nullable;
 import javax.persistence.*;
+import javax.sound.midi.Track;
+import java.lang.reflect.Array;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -68,7 +71,8 @@ public class PlaylistEntity {
         this.tracks = tracks;
     }
 
-    public void addTracks(TrackEntity... tracks) {
+    public void addTracks(TrackEntity... tracks )
+    {
         if(this.tracks == null)
             this.tracks = new ArrayList<>();
 

src/main/java/net/Broken/DB/Entity/UserStats.java

@@ -27,8 +27,7 @@ public class UserStats {
     @ColumnDefault("0")
     private Long apiCommandCount = 0L;
 
-    public UserStats() {
-    }
+    public UserStats(){}
 
     public UserStats(String guildId, UserEntity user){
         this.guildId = guildId;

src/main/java/net/Broken/DB/Repository/UserRepository.java

@@ -11,8 +11,6 @@ import java.util.List;
 
 public interface UserRepository extends CrudRepository<UserEntity, Integer>{
     List<UserEntity> findByName(String name);
-
     List<UserEntity> findByJdaId(String jdaId);
-
     List<UserEntity> findByApiToken(String apiToken);
 }

src/main/java/net/Broken/DB/Repository/UserStatsRepository.java

@@ -8,9 +8,7 @@ import java.util.List;
 
 public interface UserStatsRepository extends CrudRepository<UserStats, Long> {
     List<UserStats> findByUser(UserEntity userEntity);
-
     List<UserStats> findByGuildId(String guildId);
-
     List<UserStats> findByUserAndGuildId(UserEntity user, String guildId);
 
 }

src/main/java/net/Broken/Init.java

@@ -7,7 +7,9 @@ import net.Broken.Tools.Command.CommandLoader;
 import net.Broken.Tools.Command.SlashCommandLoader;
 import net.Broken.Tools.DayListener.DayListener;
 import net.Broken.Tools.DayListener.Listeners.DailyMadame;
+import net.Broken.Tools.DayListener.Listeners.ResetSpam;
 import net.Broken.Tools.UserManager.Stats.UserStatsUtils;
+import net.dv8tion.jda.api.AccountType;
 import net.dv8tion.jda.api.JDA;
 import net.dv8tion.jda.api.JDABuilder;
 import net.dv8tion.jda.api.OnlineStatus;
@@ -88,6 +90,7 @@ public class Init {
         SlashCommandLoader.registerSlashCommands(jda.updateCommands());
         ApiCommandLoader.load();
         DayListener dayListener = DayListener.getInstance();
+        dayListener.addListener(new ResetSpam());
         dayListener.addListener(new DailyMadame());
         dayListener.start();
         jda.addEventListener(new BotListener());

src/main/java/net/Broken/MainBot.java

@@ -1,8 +1,16 @@
 package net.Broken;
 
+import net.Broken.DB.Entity.UserEntity;
+import net.Broken.Tools.Command.CommandParser;
+import net.Broken.Tools.EmbedMessageUtils;
+import net.Broken.Tools.PrivateMessage;
+import net.Broken.Tools.UserSpamUtils;
 import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.Permission;
+import net.dv8tion.jda.api.entities.ChannelType;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.User;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.springframework.boot.ExitCodeGenerator;
@@ -23,8 +31,11 @@ public class MainBot {
 
     public static HashMap<String, Commande> commandes = new HashMap<>();
     public static HashMap<String, SlashCommand> slashCommands = new HashMap<>();
+    public static HashMap<Member, ArrayList<Message>> historique =new HashMap<>();
+    public static HashMap<Member, Integer> message_compteur =new HashMap<>();
     public static HashMap<String, Integer> mutualGuildCount =new HashMap<>();
     public static boolean roleFlag = false;
+    public static HashMap<Member, UserSpamUtils> spamUtils = new HashMap<>();
     public static JDA jda;
     public static boolean ready = false;
     public static boolean dev = false;
@@ -32,6 +43,8 @@ public class MainBot {
     public static String url= "claptrapbot.com";
 
 
+
+
     public static int messageTimeOut = 10;
     public static int gifMessageTimeOut = 30;
 
@@ -69,4 +82,65 @@ public class MainBot {
         ready = true;
 
     }
+
+    /**
+     * Perform test (admin, NSFW and private usable or not) and execute command or not
+     * @param cmd Container whit all command info
+     */
+    public static void handleCommand(CommandParser.CommandContainer cmd, UserEntity user)
+    {
+
+        if(!ready){
+            return;
+        }
+
+        if (commandes.containsKey(cmd.commande)){
+            Commande cmdObj = commandes.get(cmd.commande);
+            boolean isAdmin;
+            boolean isBotAdmin = user != null && user.isBotAdmin();
+            if(cmd.event.isFromType(ChannelType.PRIVATE)){
+                isAdmin = false;
+            }
+            else
+                isAdmin = cmd.event.getMember().hasPermission(Permission.ADMINISTRATOR);
+
+            if((!cmdObj.isAdminCmd() || isAdmin) && (!cmdObj.isBotAdminCmd() || isBotAdmin)){
+
+                    if(cmd.event.isFromType(ChannelType.PRIVATE) && commandes.get(cmd.commande).isPrivateUsable())
+                    {
+
+                        commandes.get(cmd.commande).action(cmd.args, cmd.event);
+                    }
+                    else if (!cmd.event.isFromType(ChannelType.PRIVATE))
+                    {
+                        if(!cmdObj.isNSFW() || cmd.event.getTextChannel().isNSFW()){
+                            commandes.get(cmd.commande).action(cmd.args, cmd.event);
+                        }
+                        else{
+                            cmd.event.getMessage().delete().queue();
+                        }
+
+                    }
+                    else
+                        cmd.event.getPrivateChannel().sendMessage(EmbedMessageUtils.getNoPrivate()).queue();
+
+
+
+            }
+            else{
+                if(cmd.event.isFromType(ChannelType.PRIVATE)){
+                    PrivateMessage.send(cmd.event.getAuthor(),EmbedMessageUtils.getUnautorized(), logger);
+                }
+                else{
+                    cmd.event.getTextChannel().sendMessage(EmbedMessageUtils.getUnautorized()).complete();
+                }
+            }
+        }
+        else{
+            logger.debug("Unknown command : " + cmd.commande);
+        }
+    }
+
+
+
 }

src/main/java/net/Broken/RestApi/ApiCommandLoader.java

@@ -12,7 +12,6 @@ import java.util.Set;
 public class ApiCommandLoader {
     public static HashMap<String, CommandInterface> apiCommands = new HashMap<>();
     private static Logger logger = LogManager.getLogger();
-
     public static void load(){
         logger.info("Loading Api Command...");
 //        Reflections reflections = new Reflections("net.Broken.RestApi.Command");

src/main/java/net/Broken/RestApi/CommandInterface.java

@@ -13,7 +13,6 @@ import org.springframework.http.ResponseEntity;
 public interface CommandInterface {
     /**
      * Main action
-     *
      * @param musicCommande Current guild music command
      * @param data Received data
      * @param user User who submit RestApi command

src/main/java/net/Broken/RestApi/Commands/Connect.java

@@ -22,8 +22,7 @@ public class Connect implements CommandInterface {
         VoiceChannel voiceChannel = null;
         try{
             voiceChannel = guild.getVoiceChannelById(data.chanelId);
-        } catch (NumberFormatException ignored) {
-        }
+        }catch (NumberFormatException ignored){}
 
         if(voiceChannel == null){
             return new ResponseEntity<>(new CommandResponseData(data.command,"Channel Not found"), HttpStatus.BAD_REQUEST);

src/main/java/net/Broken/RestApi/Commands/Dell.java

@@ -18,7 +18,8 @@ public class Dell implements CommandInterface {
         if(data.url != null) {
             if(AudioM.getInstance(guild).getGuildMusicManager().scheduler.remove(data.url)){
                 return new ResponseEntity<>(new CommandResponseData(data.command, "Accepted"), HttpStatus.OK);
-            } else
+            }
+            else
                 return new ResponseEntity<>(new CommandResponseData(data.command,"URL not found"), HttpStatus.NOT_FOUND);
         }
         return new ResponseEntity<>(new CommandResponseData(data.command, "Missing URL"), HttpStatus.NOT_ACCEPTABLE);

src/main/java/net/Broken/RestApi/Data/CommandResponseData.java

@@ -1,7 +1,6 @@
 package net.Broken.RestApi.Data;
 
 import com.fasterxml.jackson.annotation.JsonInclude;
-
 /**
  * Data for JSON Parsing
  */

src/main/java/net/Broken/RestApi/Data/CurrentMusicData.java

@@ -1,7 +1,10 @@
 package net.Broken.RestApi.Data;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonInclude;
-
+import com.sedmelluq.discord.lavaplayer.track.AudioTrackInfo;
+import com.sedmelluq.discord.lavaplayer.track.AudioTrackState;
 /**
  * Data for JSON Parsing
  */

src/main/java/net/Broken/RestApi/Data/Playlist/PlaylistResponseData.java

@@ -13,7 +13,6 @@ public class PlaylistResponseData {
         this.message = message;
         this.playlist = playlist;
     }
-
     public PlaylistResponseData(String message, String error) {
         this.message = message;
         this.error = error;

src/main/java/net/Broken/RestApi/Data/PlaylistData.java

@@ -1,7 +1,8 @@
 package net.Broken.RestApi.Data;
 
-import java.util.List;
+import com.sedmelluq.discord.lavaplayer.track.AudioTrackInfo;
 
+import java.util.List;
 /**
  * Data for JSON Parsing
  */

src/main/java/net/Broken/RestApi/Data/Settings/Value.java

@@ -12,7 +12,6 @@ public class Value {
         this.name = name;
         this.id = id;
     }
-
     public Value(String name, String id, boolean selected) {
         this.name = name;
         this.id = id;

src/main/java/net/Broken/RestApi/Data/UserAudioTrackData.java

@@ -2,7 +2,6 @@ package net.Broken.RestApi.Data;
 
 import com.sedmelluq.discord.lavaplayer.track.AudioTrackInfo;
 import net.Broken.audio.UserAudioTrack;
-
 /**
  * Data for JSON Parsing
  */

src/main/java/net/Broken/RestApi/GeneralApiController.java

@@ -1,5 +1,8 @@
 package net.Broken.RestApi;
 
+import net.Broken.DB.Entity.PlaylistEntity;
+import net.Broken.DB.Entity.TrackEntity;
+import net.Broken.DB.Entity.UserEntity;
 import net.Broken.DB.Repository.PlaylistRepository;
 import net.Broken.DB.Repository.TrackRepository;
 import net.Broken.DB.Repository.UserRepository;
@@ -7,10 +10,14 @@ import net.Broken.MainBot;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
+import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.RestController;
 
+import java.util.ArrayList;
+import java.util.List;
+
 @RestController
 @RequestMapping("/api/")
 public class GeneralApiController {
@@ -35,7 +42,9 @@ public class GeneralApiController {
     public ResponseEntity<String> isReady(){
         if(MainBot.ready){
             return new ResponseEntity<>(HttpStatus.OK);
-        } else {
+        }
+        else
+        {
             return new ResponseEntity<>(HttpStatus.NOT_FOUND);
         }
     }

src/main/java/net/Broken/RestApi/PlaylistAPIController.java

@@ -96,4 +96,6 @@ public class PlaylistAPIController {
     }
 
 
+
+
 }

src/main/java/net/Broken/RestApi/SettingAPIController.java

@@ -1,14 +1,23 @@
 package net.Broken.RestApi;
 
+import net.Broken.DB.Entity.GuildPreferenceEntity;
 import net.Broken.DB.Entity.UserEntity;
+import net.Broken.DB.Repository.GuildPreferenceRepository;
 import net.Broken.DB.Repository.UserRepository;
 import net.Broken.MainBot;
 import net.Broken.RestApi.Data.Settings.GetSettingsData;
 import net.Broken.RestApi.Data.Settings.ListPostSetting;
+import net.Broken.RestApi.Data.Settings.PostSetSettings;
+import net.Broken.RestApi.Data.Settings.Value;
 import net.Broken.Tools.SettingsUtils;
 import net.Broken.Tools.UserManager.Exceptions.UnknownTokenException;
 import net.Broken.Tools.UserManager.UserUtils;
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.Permission;
 import net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.Role;
+import net.dv8tion.jda.api.entities.TextChannel;
+import net.dv8tion.jda.api.entities.User;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -16,14 +25,16 @@ import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
+import javax.annotation.RegEx;
 import java.util.ArrayList;
+import java.util.List;
 
 @RestController
 @RequestMapping("/api")
 public class SettingAPIController {
+    private Logger logger = LogManager.getLogger();
     final
     UserRepository userRepository;
-    private Logger logger = LogManager.getLogger();
 
     @Autowired
     public SettingAPIController(UserRepository userRepository) {
@@ -37,7 +48,8 @@ public class SettingAPIController {
         if(settingUtils.checkPermission(token, guild)){
             Guild jdaGuild = MainBot.jda.getGuildById(guild);
             return new ResponseEntity<>( settingUtils.extractSettings(jdaGuild), HttpStatus.OK);
-        } else {
+        }
+        else{
                 return new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
         }
     }
@@ -63,11 +75,13 @@ public class SettingAPIController {
             }
 
 
-        } else {
+        }
+        else{
             logger.warn("Try to change setting, UNAUTHORIZED. TOKEN: " + token + " GUILD: " + guild);
             return new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
         }
     }
 
 
+
 }

src/main/java/net/Broken/RestApi/UserManagerAPIController.java

@@ -1,15 +1,13 @@
 package net.Broken.RestApi;
 
+import net.Broken.DB.Entity.PendingUserEntity;
 import net.Broken.DB.Entity.UserEntity;
 import net.Broken.DB.Repository.PendingUserRepository;
 import net.Broken.DB.Repository.UserRepository;
 import net.Broken.MainBot;
-import net.Broken.RestApi.Data.UserManager.GuildInfo;
-import net.Broken.RestApi.Data.UserManager.UserConnectionData;
-import net.Broken.RestApi.Data.UserManager.UserInfoData;
-import net.Broken.Tools.UserManager.Exceptions.PasswordNotMatchException;
-import net.Broken.Tools.UserManager.Exceptions.UnknownTokenException;
-import net.Broken.Tools.UserManager.Exceptions.UserNotFoundException;
+import net.Broken.RestApi.Data.CommandResponseData;
+import net.Broken.RestApi.Data.UserManager.*;
+import net.Broken.Tools.UserManager.Exceptions.*;
 import net.Broken.Tools.UserManager.Oauth;
 import net.Broken.Tools.UserManager.Stats.GuildStatsPack;
 import net.Broken.Tools.UserManager.Stats.UserStatsUtils;
@@ -17,6 +15,7 @@ import net.Broken.Tools.UserManager.UserUtils;
 import net.dv8tion.jda.api.Permission;
 import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.User;
+import org.apache.http.HttpResponse;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -35,12 +34,15 @@ import java.util.List;
 @RestController
 @RequestMapping("/api/userManagement")
 public class UserManagerAPIController {
+    Logger logger = LogManager.getLogger();
     final
     PendingUserRepository pendingUserRepository;
+
     final
     UserRepository userRepository;
+
     private final PasswordEncoder passwordEncoder;
-    Logger logger = LogManager.getLogger();
+
     UserUtils userUtils = UserUtils.getInstance();
 
     @Autowired
@@ -51,43 +53,44 @@ public class UserManagerAPIController {
     }
 
 
-//    @RequestMapping(value = "/preRegister", method = RequestMethod.POST)
-//    public ResponseEntity<CheckResposeData> command(@RequestBody UserInfoData data) {
-//        if (data != null && data.name != null) {
-//            try {
-//                String id = userUtils.sendCheckToken(pendingUserRepository, userRepository, passwordEncoder, data);
-//                return new ResponseEntity<>(new CheckResposeData(true, data.name, "Message sent", id), HttpStatus.OK);
-//            } catch (UserNotFoundException e) {
-//                logger.warn("User \"" + data.name + "\" not found!");
-//                return new ResponseEntity<>(new CheckResposeData(false, data.name, "User not found on server!", ""), HttpStatus.NOT_FOUND);
-//            } catch (PasswordNotMatchException userAlreadyRegistered) {
-//                return new ResponseEntity<>(new CheckResposeData(false, data.name, "User already registered in pending database and password not match!", ""), HttpStatus.NOT_ACCEPTABLE);
-//
-//            } catch (UserAlreadyRegistered userAlreadyRegistered) {
-//                return new ResponseEntity<>(new CheckResposeData(false, data.name, "User already registered in database!", ""), HttpStatus.NOT_ACCEPTABLE);
-//            }
-//        } else {
-//            return new ResponseEntity<>(new CheckResposeData(false, "", "Missing parameter(s)", ""), HttpStatus.BAD_REQUEST);
-//        }
-//    }
+    @RequestMapping(value = "/preRegister", method = RequestMethod.POST)
+    public ResponseEntity<CheckResposeData> command(@RequestBody UserInfoData data){
+        if(data != null && data.name != null) {
+            try {
+                String id = userUtils.sendCheckToken(pendingUserRepository, userRepository, passwordEncoder, data);
+                return new ResponseEntity<>(new CheckResposeData(true, data.name, "Message sent", id), HttpStatus.OK);
+            } catch (UserNotFoundException e) {
+                logger.warn("User \"" + data.name + "\" not found!");
+                return new ResponseEntity<>(new CheckResposeData(false, data.name, "User not found on server!",""), HttpStatus.NOT_FOUND);
+            } catch (PasswordNotMatchException userAlreadyRegistered) {
+                return new ResponseEntity<>(new CheckResposeData(false, data.name, "User already registered in pending database and password not match!",""), HttpStatus.NOT_ACCEPTABLE);
 
-//    @RequestMapping(value = "/confirmAccount", method = RequestMethod.POST)
-//    public ResponseEntity<UserConnectionData> confirAccount(@RequestBody ConfirmData data) {
-//        try {
-//            PendingUserEntity pUser = userUtils.confirmCheckToken(pendingUserRepository, Integer.parseInt(data.id), data.checkToken);
-//            UserEntity user = new UserEntity(pUser, userUtils.generateApiToken());
-//            userRepository.save(user);
-//            pendingUserRepository.delete(pUser);
-//
-//            return new ResponseEntity<>(new UserConnectionData(true, user.getName(), user.getApiToken(), ""), HttpStatus.OK);
-//        } catch (TokenNotMatch tokenNotMatch) {
-//            logger.warn("Pre token not match for " + data.id + "!");
-//            return new ResponseEntity<>(new UserConnectionData(false, "Token not match!", "token"), HttpStatus.NOT_ACCEPTABLE);
-//        } catch (UserNotFoundException e) {
-//            logger.warn("Id not found in DB (" + data.id + ")");
-//            return new ResponseEntity<>(new UserConnectionData(false, "User not found on DB!", "user"), HttpStatus.NOT_ACCEPTABLE);
-//        }
-//    }
+            } catch (UserAlreadyRegistered userAlreadyRegistered) {
+                return new ResponseEntity<>(new CheckResposeData(false, data.name, "User already registered in database!",""), HttpStatus.NOT_ACCEPTABLE);
+            }
+        }
+        else{
+            return new ResponseEntity<>(new CheckResposeData(false, "", "Missing parameter(s)",""), HttpStatus.BAD_REQUEST);
+        }
+    }
+
+    @RequestMapping(value = "/confirmAccount", method = RequestMethod.POST)
+    public ResponseEntity<UserConnectionData> confirAccount(@RequestBody ConfirmData data){
+        try {
+            PendingUserEntity pUser = userUtils.confirmCheckToken(pendingUserRepository, Integer.parseInt(data.id), data.checkToken);
+            UserEntity user = new UserEntity(pUser, userUtils.generateApiToken());
+            userRepository.save(user);
+            pendingUserRepository.delete(pUser);
+
+            return new ResponseEntity<>(new UserConnectionData(true, user.getName(), user.getApiToken(),""),HttpStatus.OK);
+        } catch (TokenNotMatch tokenNotMatch) {
+            logger.warn("Pre token not match for "+data.id+"!");
+            return new ResponseEntity<>(new UserConnectionData(false,"Token not match!","token"),HttpStatus.NOT_ACCEPTABLE);
+        } catch (UserNotFoundException e) {
+            logger.warn("Id not found in DB ("+data.id+")");
+            return new ResponseEntity<>(new UserConnectionData(false,"User not found on DB!", "user"),HttpStatus.NOT_ACCEPTABLE);
+        }
+    }
 
     @RequestMapping(value = "/requestToken", method = RequestMethod.POST)
     public ResponseEntity<UserConnectionData> requestToken(@RequestBody UserInfoData data){
@@ -126,6 +129,8 @@ public class UserManagerAPIController {
     }
 
 
+
+
     @RequestMapping(value = "/oauthLogin", method = RequestMethod.POST)
     public ResponseEntity<UserConnectionData> oauthLogin(@RequestParam(value = "token") String discordToken){
         logger.debug(discordToken);
@@ -134,6 +139,7 @@ public class UserManagerAPIController {
         return new ResponseEntity<>(new UserConnectionData(true, user.getName(), user.getApiToken(), ""), HttpStatus.OK);
 
 
+
     }
 
 
@@ -161,6 +167,7 @@ public class UserManagerAPIController {
             return new ResponseEntity<>(UserStatsUtils.getINSTANCE().getStatPack(user, guildID), HttpStatus.OK);
 
 
+
         } catch (UnknownTokenException e) {
             logger.info("Token check fail");
             return new ResponseEntity(HttpStatus.UNAUTHORIZED);
@@ -168,4 +175,7 @@ public class UserManagerAPIController {
     }
 
 
+
+
+
 }

src/main/java/net/Broken/SlashCommand.java

@@ -12,7 +12,6 @@ import java.util.List;
 public interface SlashCommand {
     /**
      * Main action of command
-     *
      * @param args Command args.
      * @param event Command MessageReceivedEvent
      */
@@ -26,14 +25,12 @@ public interface SlashCommand {
 
     /**
      * Determines if the command is usable only by bot level admin user
-     *
      * @return boolean
      */
     boolean isBotAdminCmd();
 
     /**
      * Determines if the command is only usable on NSFW channels
-     *
      * @return boolean
      */
     boolean isNSFW();

src/main/java/net/Broken/SlashCommands/Cat.java

@@ -1,10 +1,15 @@
 package net.Broken.SlashCommands;
 
 
+import net.Broken.Commande;
 import net.Broken.SlashCommand;
 import net.Broken.Tools.EmbedMessageUtils;
+import net.dv8tion.jda.api.EmbedBuilder;
 import net.dv8tion.jda.api.MessageBuilder;
+import net.dv8tion.jda.api.entities.ChannelType;
+import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
 import net.dv8tion.jda.api.interactions.commands.build.OptionData;
 import net.dv8tion.jda.api.interactions.commands.build.SubcommandData;
 import org.apache.logging.log4j.LogManager;
@@ -23,9 +28,7 @@ import java.util.List;
  * Command that return a random picture of cat.
  */
 public class Cat implements SlashCommand {
-    private Logger logger = LogManager.getLogger();
-    ;
-
+    private Logger logger = LogManager.getLogger();;
     @Override
     public void action(SlashCommandEvent event) {
         try {
@@ -45,7 +48,7 @@ public class Cat implements SlashCommand {
 
         } catch (IOException e) {
             logger.catching(e);
-            event.reply(new MessageBuilder().setEmbeds(EmbedMessageUtils.getInternalError()).build()).setEphemeral(true).queue();
+            event.reply(new MessageBuilder().setEmbeds(EmbedMessageUtils.getInternalError()).build()).queue();
         }
 
 
@@ -58,7 +61,7 @@ public class Cat implements SlashCommand {
 
     @Override
     public List<OptionData> getOptions() {
-        return null;
+        return new ArrayList<>();
     }
 
     @Override

src/main/java/net/Broken/SlashCommands/Clear.java

@@ -1,58 +0,0 @@
-package net.Broken.SlashCommands;
-
-import net.Broken.SlashCommand;
-import net.Broken.Tools.EmbedMessageUtils;
-import net.dv8tion.jda.api.EmbedBuilder;
-import net.dv8tion.jda.api.MessageBuilder;
-import net.dv8tion.jda.api.Permission;
-import net.dv8tion.jda.api.entities.Message;
-import net.dv8tion.jda.api.entities.MessageChannel;
-import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
-import net.dv8tion.jda.api.interactions.commands.OptionType;
-import net.dv8tion.jda.api.interactions.commands.build.OptionData;
-import net.dv8tion.jda.api.interactions.commands.build.SubcommandData;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class Clear implements SlashCommand {
-    @Override
-    public void action(SlashCommandEvent event) {
-        if (event.getMember().hasPermission(Permission.MESSAGE_MANAGE)) {
-            event.reply(":white_check_mark: Done").setEphemeral(true).queue();
-            long n = event.getOption("n").getAsLong();
-            MessageChannel chanel = event.getChannel();
-            chanel.getIterableHistory().takeAsync((int) n).thenAccept(chanel::purgeMessages);
-        } else {
-            Message message = new MessageBuilder().setEmbeds(EmbedMessageUtils.getFlushError("You are not a supreme being, you cannot do that !")).build();
-            event.reply(message).setEphemeral(true).queue();
-        }
-    }
-
-    @Override
-    public String getDescription() {
-        return "Clear the last [n] message(s)";
-    }
-
-    @Override
-    public List<OptionData> getOptions() {
-        ArrayList<OptionData> options = new ArrayList<>();
-        options.add(new OptionData(OptionType.INTEGER, "n", "The number of message(s) to clear", true));
-        return options;
-    }
-
-    @Override
-    public List<SubcommandData> getSubcommands() {
-        return null;
-    }
-
-    @Override
-    public boolean isBotAdminCmd() {
-        return false;
-    }
-
-    @Override
-    public boolean isNSFW() {
-        return false;
-    }
-}

src/main/java/net/Broken/SlashCommands/Invite.java

@@ -1,41 +0,0 @@
-package net.Broken.SlashCommands;
-
-import net.Broken.SlashCommand;
-import net.dv8tion.jda.api.Permission;
-import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
-import net.dv8tion.jda.api.interactions.commands.build.OptionData;
-import net.dv8tion.jda.api.interactions.commands.build.SubcommandData;
-
-import java.util.List;
-
-public class Invite implements SlashCommand {
-    @Override
-    public void action(SlashCommandEvent event) {
-        event.reply(event.getJDA().setRequiredScopes("bot", "applications.commands").getInviteUrl(Permission.ADMINISTRATOR)).setEphemeral(true).queue();
-    }
-
-    @Override
-    public String getDescription() {
-        return "Get the link to invite this bot to your server";
-    }
-
-    @Override
-    public List<OptionData> getOptions() {
-        return null;
-    }
-
-    @Override
-    public List<SubcommandData> getSubcommands() {
-        return null;
-    }
-
-    @Override
-    public boolean isBotAdminCmd() {
-        return false;
-    }
-
-    @Override
-    public boolean isNSFW() {
-        return false;
-    }
-}

src/main/java/net/Broken/SlashCommands/Music.java

@@ -1,8 +1,10 @@
 package net.Broken.SlashCommands;
 
 
+import net.Broken.MainBot;
 import net.Broken.SlashCommand;
 import net.Broken.Tools.EmbedMessageUtils;
+import net.Broken.Tools.MessageTimeOut;
 import net.Broken.audio.AudioM;
 import net.dv8tion.jda.api.MessageBuilder;
 import net.dv8tion.jda.api.entities.Message;
@@ -14,7 +16,13 @@ import net.dv8tion.jda.api.interactions.commands.build.OptionData;
 import net.dv8tion.jda.api.interactions.commands.build.SubcommandData;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.json.JSONObject;
 
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.net.URLConnection;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -44,7 +52,7 @@ public class Music implements SlashCommand {
                     }
                 } else {
                     Message message = new MessageBuilder().setEmbeds(EmbedMessageUtils.getMusicError("You are not in a voice channel !")).build();
-                    event.getHook().setEphemeral(true).sendMessage(message).queue();
+                    event.getHook().sendMessage(message).queue();
                 }
                 break;
             case "add":
@@ -55,7 +63,8 @@ public class Music implements SlashCommand {
                 }
                 if(event.getOption("playlist-limit") == null){
                     audio.add(event, url.getAsString(),30, next);
-                } else {
+                }
+                else{
                     long limit = event.getOption("playlist-limit").getAsLong();
                     audio.add(event, url.getAsString(), (int) limit, next);
                 }

src/main/java/net/Broken/SpringContext.java

@@ -12,12 +12,13 @@ public class SpringContext implements ApplicationContextAware {
     @Autowired
     static ApplicationContext context;
 
-    public static ApplicationContext getAppContext() {
-        return context;
-    }
-
     @Override
     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
         context = applicationContext;
     }
+
+
+    public static ApplicationContext getAppContext(){
+        return context;
+    }
 }

src/main/java/net/Broken/Tools/AntiSpam.java

@@ -0,0 +1,173 @@
+package net.Broken.Tools;
+
+import net.Broken.MainBot;
+import net.Broken.Commands.Move;
+import net.dv8tion.jda.api.entities.*;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import net.dv8tion.jda.api.exceptions.HierarchyException;
+import net.dv8tion.jda.api.managers.GuildManager;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+
+import java.awt.*;
+import java.util.ArrayList;
+import java.util.List;
+
+import static java.lang.Thread.sleep;
+
+
+/**
+ * AntiSpam punishment system
+ */
+public class AntiSpam {
+
+    Logger logger = LogManager.getLogger();
+    public Move move = new Move();
+    public AntiSpam() {
+
+    }
+
+    /**
+     * Send user to Spam role
+     * @param user User to punish
+     * @param guild Guild
+     * @param guildManager GuildManager
+     * @param incrMulti True for increment punishment time
+     * @param event Message Received Event
+     */
+    public void extermine(Member user, Guild guild, GuildManager guildManager, Boolean incrMulti, MessageReceivedEvent event){
+        try {
+            sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        // On créer un nouvelle case dans le tableau des statuts si il n'y est pas
+        if(!MainBot.spamUtils.containsKey(user))
+        {
+            List<Message> messages = new ArrayList<>();
+            messages.addAll(MainBot.historique.get(user));
+            MainBot.spamUtils.put(user,new UserSpamUtils(user,messages));
+        }
+        // On verrifie que l'uttilisateur n'est pas deja en spam
+        if(!MainBot.spamUtils.get(user).isOnSpam())
+        {
+            //l'utilisateur n'est pas deja en spam
+            if(MainBot.spamUtils.get(user).getMultip() != 0)
+            {
+                if(MainBot.spamUtils.get(user).getMultip()<45 && incrMulti)
+                {
+                    MainBot.spamUtils.get(user).setMultip(MainBot.spamUtils.get(user).getMultip()*2);
+                }
+            }
+            else
+                MainBot.spamUtils.get(user).setMultip(1);
+
+           logger.info("Starting protocol 66 on "+user.getEffectiveName()+" with a multiplicator of "+MainBot.spamUtils.get(user));
+
+            if(!MainBot.spamUtils.get(user).isOnSpam())
+            {
+                MainBot.spamUtils.get(user).setOnSpam(true);
+                List<Role> spm = guild.getRolesByName("Spammer", false);
+                if(spm.size() != 0){
+                    try{
+                        move.exc(user, spm, true, guild, guildManager);
+                        MainBot.spamUtils.get(user).addMessage(event.getTextChannel().sendMessage(EmbedMessageUtils.getSpamExtermine(user,MainBot.spamUtils.get(user.getUser()).getMultip())).complete());
+                        MainBot.spamUtils.get(user).setMinuteur(new Minuteur(MainBot.spamUtils.get(user).getMultip(), move.user, move.saveRoleUser, move.serveur, move.serveurManager,event));
+                        MainBot.spamUtils.get(user).launchMinuteur();
+                    }catch (HierarchyException e){
+                        Message rest = event.getTextChannel().sendMessage(EmbedMessageUtils.getMoveError("You cannot move a "+user.getRoles().get(0).getAsMention())).complete();
+                        List<Message> messages = new ArrayList<Message>(){{
+                            add(rest);
+                            add(event.getMessage());
+                        }};
+                        new MessageTimeOut(messages,MainBot.messageTimeOut).start();
+                        MainBot.spamUtils.get(user).setOnSpam(false);
+                    }
+                }
+                else {
+                    MessageEmbed msg = EmbedMessageUtils.buildStandar(EmbedMessageUtils.getError("\nSpam role not found, you need to create it!"));
+                    event.getTextChannel().sendMessage(msg).complete();
+                }
+
+
+            }
+        }
+
+
+
+
+    }
+
+    /**
+     * Timer to auto remove user from Spam role
+     */
+    public class Minuteur extends Thread{
+        public TextChannel chanel;
+        public List<Role> saveRoleUser;
+        public Member user;
+        public Guild serveur;
+        public GuildManager serveurManager;
+        public int multip;
+        public MessageReceivedEvent event;
+        public int timeLeft;
+
+
+        public Minuteur(int multip, Member user, List<Role> saveRoleUser, Guild serveur, GuildManager serveurManager, MessageReceivedEvent event )
+        {
+            this.multip=multip;
+            this.user=user;
+            this.saveRoleUser=saveRoleUser;
+            this.serveur=serveur;
+            this.serveurManager=serveurManager;
+            this.event=event;
+            this.chanel=event.getTextChannel();
+            this.timeLeft = 60*multip;
+        }
+
+
+        @Override
+        public void run() {
+            logger.info("["+user.getEffectiveName()+"] Start for "+multip+"min");
+            while (MainBot.spamUtils.get(user).isOnSpam())
+            {
+                try {
+                sleep(1000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                if(timeLeft<=0)
+                {
+                    MainBot.spamUtils.get(user.getUser()).setOnSpam(false);
+                }
+                timeLeft--;
+            }
+            logger.info("["+user.getEffectiveName()+"] End of spam for "+user.getEffectiveName()+" after "+multip+"min.");
+            try {
+                move.exc(user, saveRoleUser, true, serveur, serveurManager);    //aSaveroleUser=saveRoleUser.get(i)
+            }catch (HierarchyException e){
+                Message rest = event.getTextChannel().sendMessage(EmbedMessageUtils.getMoveError("You cannot move "+user.getRoles().get(0).getAsMention())).complete();
+                List<Message> messages = new ArrayList<Message>(){{
+                    add(rest);
+                    add(event.getMessage());
+                }};
+                new MessageTimeOut(messages,MainBot.messageTimeOut).start();
+                logger.error("Hierarchy error");
+            }
+            logger.info("["+user.getEffectiveName()+"] End for "+multip+"min");
+            new MessageTimeOut(new ArrayList<>(MainBot.spamUtils.get(user).getMessages()),0).start();
+            MainBot.spamUtils.get(user).clearAndAdd(chanel.sendMessage(EmbedMessageUtils.getSpamPardon(user)).complete());
+            new MessageTimeOut(MainBot.spamUtils.get(user).getMessages(),60).start();
+
+            //                                                                                                                                                                                        #-----------------------------------------------#
+
+
+        }
+    }
+
+
+
+
+
+}

src/main/java/net/Broken/Tools/AutoVoiceChannel.java

@@ -9,10 +9,7 @@ import net.dv8tion.jda.api.requests.RestAction;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 
 import static net.Broken.MainBot.jda;
 
@@ -23,10 +20,6 @@ public class AutoVoiceChannel {
     private final String guildID;
     private final HashMap<Integer, String> createdChannels = new HashMap<>();
 
-    public AutoVoiceChannel(Guild guild) {
-        this.guildID = guild.getId();
-    }
-
     public static AutoVoiceChannel getInstance(Guild guild) {
         if (INSTANCE_MAP.get(guild.getId()) == null) {
             INSTANCE_MAP.put(guild.getId(), new AutoVoiceChannel(guild));
@@ -34,6 +27,10 @@ public class AutoVoiceChannel {
         return INSTANCE_MAP.get(guild.getId());
     }
 
+    public AutoVoiceChannel(Guild guild) {
+        this.guildID = guild.getId();
+    }
+
     public void join(VoiceChannel voiceChannel) {
         Guild guild = jda.getGuildById(guildID);
         if (guild == null)

src/main/java/net/Broken/Tools/Command/CommandParser.java

@@ -16,12 +16,12 @@ public class CommandParser {
 
     /**
      * Parse raw received string.
-     *
      * @param brt Raw command string.
      * @param e Event
      * @return Readable container that contain all useful data
      */
-    public CommandContainer parse(String brt, MessageReceivedEvent e) {
+    public CommandContainer parse(String brt, MessageReceivedEvent e)
+    {
         ArrayList<String> split =new ArrayList<String>();
         String brut =brt;
         String sansTete = brut.replaceFirst("//","");
@@ -40,6 +40,7 @@ public class CommandParser {
             args[i]=args[i].replace('$',' ');
 
 
+
         logger.info("Author: "+e.getAuthor().getName()+", Command: "+commande+", args: "+ Arrays.toString(args));
 
         return new CommandContainer(brut, sansTete, splitSansTete, commande, args, e);
@@ -57,7 +58,8 @@ public class CommandParser {
         public final String[] args;
         public final MessageReceivedEvent event;
 
-        public CommandContainer(String brut, String sansTete, String[] splitSansTete, String commande, String[] args, MessageReceivedEvent e) {
+        public CommandContainer(String brut, String sansTete, String[] splitSansTete, String commande, String[] args, MessageReceivedEvent e)
+        {
             this.brut=brut;
             this.sansTete=sansTete;
             this.splitSansTete=splitSansTete;

src/main/java/net/Broken/Tools/Command/NumberedCommande.java

@@ -1,5 +1,4 @@
 package net.Broken.Tools.Command;
-
 import net.Broken.Commande;
 import net.Broken.Tools.FindContentOnWebPage;
 import net.Broken.Tools.LimitChecker;
@@ -12,6 +11,7 @@ import java.io.IOException;
 import java.net.HttpURLConnection;
 import java.net.URL;
 import java.util.ArrayList;
+import java.util.Queue;
 import java.util.concurrent.LinkedBlockingQueue;
 
 /**
@@ -19,6 +19,7 @@ import java.util.concurrent.LinkedBlockingQueue;
  */
 @Ignore
 public abstract class NumberedCommande implements Commande{
+    private Logger logger = LogManager.getLogger();
     protected int minNumber = 1;
     protected int maxNumber = -1;
     protected String baseURL;
@@ -26,11 +27,9 @@ public abstract class NumberedCommande implements Commande {
     protected String htmlType;
     protected String urlSuffix;
     protected LinkedBlockingQueue<Integer> randomQueue = new LinkedBlockingQueue<>();
-    private Logger logger = LogManager.getLogger();
 
     /**
      * Default constructor
-     *
      * @param logger Logger used for logs
      * @param baseURL WebSite base url
      * @param divClass DivClass to search to extract image
@@ -58,12 +57,16 @@ public abstract class NumberedCommande implements Commande {
 
     @Override
     public void action(String[] args, MessageReceivedEvent event) {
-        try {
-            if (args.length == 0) {
+        try
+        {
+            if(args.length == 0)
+            {
                String result = poll();
                event.getTextChannel().sendMessage(event.getAuthor().getAsMention()+"\n"+result).queue();
 
-            } else {
+            }
+            else
+            {
                 switch (args[0].toLowerCase()) {
                     case "update":
                         logger.info("update commande from " + event.getMessage().getAuthor().getName());

src/main/java/net/Broken/Tools/Command/SlashCommandLoader.java

@@ -1,11 +1,13 @@
 package net.Broken.Tools.Command;
 
+import net.Broken.Commande;
 import net.Broken.MainBot;
 import net.Broken.SlashCommand;
 import net.dv8tion.jda.api.interactions.commands.build.CommandData;
 import net.dv8tion.jda.api.requests.restaction.CommandListUpdateAction;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.jboss.jandex.Main;
 import org.reflections.Reflections;
 import org.reflections.util.ClasspathHelper;
 import org.reflections.util.ConfigurationBuilder;
@@ -46,8 +48,7 @@ public class SlashCommandLoader {
                 }else{
                     try {
                         MainBot.slashCommands.put(name, command.getDeclaredConstructor().newInstance());
-                    } catch (InstantiationException | IllegalAccessException | InvocationTargetException |
-                             NoSuchMethodException e) {
+                    } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
                         logger.error("Failed to load " + name + "!");
                     }
 

src/main/java/net/Broken/Tools/DayListener/DayListener.java

@@ -1,5 +1,6 @@
 package net.Broken.Tools.DayListener;
-
+import net.Broken.Commands.Spam;
+import net.dv8tion.jda.api.exceptions.RateLimitedException;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -11,14 +12,15 @@ import java.util.GregorianCalendar;
  * Day change listener
  */
 public class DayListener extends Thread {
-    private static DayListener INSTANCE = new DayListener();
     private Logger logger = LogManager.getLogger();
     private Calendar calendar;
     private int previousDay;
+
     /**
      * List of listeners to need to be triggered
      */
     private ArrayList<NewDayListener> listeners = new ArrayList<>();
+    private static DayListener INSTANCE = new DayListener();
 
 
     /**
@@ -32,16 +34,15 @@ public class DayListener extends Thread {
 
     /**
      * Singleton
-     *
      * @return Unique DayListener instance.
      */
-    public static DayListener getInstance() {
+    public static DayListener getInstance()
+    {
         return INSTANCE;
     }
 
     /**
      * Add Listener who will be triggered
-     *
      * @param listener
      */
     public void addListener(NewDayListener listener){
@@ -68,9 +69,11 @@ public class DayListener extends Thread {
      */
     @Override
     public void run() {
-        while (true) {
+        while(true)
+        {
             calendar = Calendar.getInstance();
-            if (calendar.get(GregorianCalendar.DAY_OF_MONTH) != previousDay) {
+            if(calendar.get(GregorianCalendar.DAY_OF_MONTH) != previousDay)
+            {
                 LogManager.getLogger().info("New day triggered!");
                 trigger();
                 previousDay = calendar.get(GregorianCalendar.DAY_OF_MONTH);

src/main/java/net/Broken/Tools/DayListener/Listeners/DailyMadame.java

@@ -7,6 +7,7 @@ import net.Broken.MainBot;
 import net.Broken.SpringContext;
 import net.Broken.Tools.DayListener.NewDayListener;
 import net.Broken.Tools.FindContentOnWebPage;
+import net.Broken.Tools.Redirection;
 import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.TextChannel;
 import org.apache.logging.log4j.LogManager;
@@ -14,9 +15,11 @@ import org.apache.logging.log4j.Logger;
 import org.springframework.context.ApplicationContext;
 
 import java.io.IOException;
+import java.text.SimpleDateFormat;
 import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
 import java.util.Calendar;
+import java.util.Date;
 import java.util.List;
 
 /**
@@ -25,13 +28,13 @@ import java.util.List;
 public class DailyMadame implements NewDayListener{
 
     private GuildPreferenceRepository guildPreferenceRepository;
-    private Logger logger = LogManager.getLogger();
 
     public DailyMadame() {
         ApplicationContext context = SpringContext.getAppContext();
         guildPreferenceRepository = (GuildPreferenceRepository) context.getBean("guildPreferenceRepository");
     }
 
+    private Logger logger = LogManager.getLogger();
     @Override
     public void onNewDay() {
 
@@ -55,12 +58,15 @@ public class DailyMadame implements NewDayListener {
             }
 
 
+
+
             for(Guild guild : guilds){
                 TextChannel chanel = null;
                 logger.debug(guild.getName());
                 List<GuildPreferenceEntity> guildPref = guildPreferenceRepository.findByGuildId(guild.getId());
                 if( guildPref.size() > 0 && guildPref.get(0).isDailyMadame()){
-                    for (TextChannel iterator : guild.getTextChannels()) {
+                    for(TextChannel iterator : guild.getTextChannels())
+                    {
                         if(iterator.isNSFW() && iterator.canTalk()){
                             chanel = iterator;
                             logger.debug("break: " + chanel.getName());
@@ -72,7 +78,8 @@ public class DailyMadame implements NewDayListener {
                         chanel.sendMessage("Madame of the day :kissing_heart: \n" + imgUrl).queue();
 
 
-                    } else {
+                    }
+                    else {
                         logger.info("No NSFW chanel found for " + guild.getName() + ", ignoring it!");
                     }
                 }

src/main/java/net/Broken/Tools/DayListener/Listeners/ResetSpam.java

@@ -0,0 +1,24 @@
+package net.Broken.Tools.DayListener.Listeners;
+
+import net.Broken.Commands.Spam;
+import net.Broken.Tools.DayListener.NewDayListener;
+import net.dv8tion.jda.api.exceptions.RateLimitedException;
+
+import java.util.GregorianCalendar;
+
+/**
+ * Daily spam reset
+ */
+public class ResetSpam implements NewDayListener {
+    @Override
+    public void onNewDay() {
+        Spam spam = new Spam();
+        String str[] = {"all"};
+
+        try {
+            spam.reset(null,str);
+        } catch (RateLimitedException e) {
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/net/Broken/Tools/EmbedMessageUtils.java

@@ -1,13 +1,18 @@
 package net.Broken.Tools;
 
+import net.Broken.DB.Entity.GuildPreferenceEntity;
 import net.Broken.MainBot;
 import net.Broken.audio.Youtube.SearchResult;
+import net.Broken.audio.Youtube.YoutubeTools;
 import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.MessageEmbed;
 
 import java.awt.*;
 import java.io.FileNotFoundException;
 import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -15,15 +20,26 @@ import java.util.Map;
  * Pre build Message Embed
  */
 public class EmbedMessageUtils {
+    public static MessageEmbed getUnknowCommand() {
+        return new EmbedBuilder().setTitle(":warning: Unknown command! :warning:").setDescription(":arrow_right: Use `//help` to see the available commands.").setColor(Color.orange).setFooter(MainBot.url, MainBot.jda.getSelfUser().getAvatarUrl()).setTimestamp(Instant.now()).build();
+
+    }
 
     public static EmbedBuilder getError(String message) {
         EmbedBuilder temp = new EmbedBuilder().setTitle(":warning: Error! :warning:").setColor(Color.red).setDescription(message);
         return temp;
+
+
     }
 
+    public static MessageEmbed getNoPrivate(){
+        EmbedBuilder temp = new EmbedBuilder().setTitle(":warning: Command not available in private :warning:").setDescription(":arrow_right: Use `//help` to see the available commands.").setColor(Color.red);
+        return buildStandar(temp);
+    }
 
     public static MessageEmbed getMusicError(String message){
         return new EmbedBuilder().setTitle(":warning: Musique Error :warning:").setDescription(":arrow_right: "+message).setFooter("'//help music' for more info.",MainBot.jda.getSelfUser().getAvatarUrl()).setTimestamp(Instant.now()).setColor(Color.red).setFooter(MainBot.url, MainBot.jda.getSelfUser().getAvatarUrl()).build();
+
     }
 
     public static MessageEmbed getMusicOk(String message) {
@@ -31,28 +47,75 @@ public class EmbedMessageUtils {
         return buildStandar(temp);
     }
 
-    public static MessageEmbed getFlushError(String message) {
-        return buildStandar(new EmbedBuilder().setTitle(":warning: Flush Error :warning: ").setDescription(message).setColor(Color.red));
+    public static MessageEmbed getSpamExtermine(Member autor, int multi) {
+        return new EmbedBuilder().setTitle(":mute: Spam Hunter :mute:").setDescription(autor.getAsMention() + " detected as spam !\n\nSee you in __**" + multi + "**__ minutes!").setImage("https://media.giphy.com/media/WVudyGEaizNeg/giphy.gif").setFooter("Spam info available with '//spaminfo' in private.", MainBot.jda.getSelfUser().getAvatarUrl()).setTimestamp(Instant.now()).setTimestamp(Instant.now()).setColor(Color.orange).setColor(Color.orange).build();
     }
 
+    public static MessageEmbed getSpamPardon(Member autor) {
+        return new EmbedBuilder().setTitle(":mute: Spam Hunter :mute:").setDescription(autor.getAsMention() + " is back , watch out!\nI'm watching you!").setImage("https://media.giphy.com/media/3o7TKwBctlv08kY08M/giphy.gif").setFooter("Spam info available with '//spaminfo' in private.", MainBot.jda.getSelfUser().getAvatarUrl()).setTimestamp(Instant.now()).setColor(Color.orange).build();
+    }
+
+    public static MessageEmbed getHelp(String command) throws FileNotFoundException {
+        String name = command.substring(0, 1).toUpperCase() + command.substring(1).toLowerCase();
+        String message = new ResourceLoader().getFile("Help/"+name+"/en/main.md");
+        EmbedBuilder temp = new EmbedBuilder().setTitle(":question: " + command.substring(0, 1).toUpperCase() + command.substring(1).toLowerCase() + " :question: ").setDescription(message).setColor(Color.green);
+        return buildStandar(temp);
+    }
+
+    public static MessageEmbed getMoveError(String message) {
+        return new EmbedBuilder().setTitle(":warning: Move Error :warning: ").setDescription(message).setColor(Color.red).setFooter("'//help move' for more info.", MainBot.jda.getSelfUser().getAvatarUrl()).setTimestamp(Instant.now()).build();
+    }
+
+    public static MessageEmbed getMoveOk(String message) {
+        EmbedBuilder temp = new EmbedBuilder().setTitle(":arrow_left: Move :arrow_right:  ").setDescription(message).setColor(Color.green);
+        return buildStandar(temp);
+    }
+
+    public static MessageEmbed getSpamError(String message) {
+        return new EmbedBuilder().setTitle(":warning: Spam Error :warning: ").setDescription(message).setColor(Color.red).setFooter("'//help spam' for more info.", MainBot.jda.getSelfUser().getAvatarUrl()).build();
+    }
+
+    public static MessageEmbed getSpamError(String message, String sub) {
+        return new EmbedBuilder().setTitle(":warning: Spam Error :warning: ").setDescription(message).setColor(Color.red).setFooter("'//help spam "+sub+"' for more info.", MainBot.jda.getSelfUser().getAvatarUrl()).setThumbnail(MainBot.jda.getSelfUser().getAvatarUrl()).setTimestamp(Instant.now()).build();
+    }
+
+    public static MessageEmbed getSpamInfo(String message) {
+        EmbedBuilder temp = new EmbedBuilder().setTitle(":hourglass: Spam Info :hourglass:").setDescription(message).setColor(Color.green);
+        return buildStandar(temp);
+    }
+
+    public static MessageEmbed getFlushError(String message) {
+        return new EmbedBuilder().setTitle(":warning: Flush Error :warning: ").setDescription(message).setColor(Color.red).setFooter("'//help flush' for more info. ", MainBot.jda.getSelfUser().getAvatarUrl()).setTimestamp(Instant.now()).build();
+    }
+
+    public static MessageEmbed getRegister(String message) {
+        return buildStandar(new EmbedBuilder().setTitle(":pencil: Web Registration :pencil:").setDescription(message).setColor(Color.green));
+    }
 
     public static MessageEmbed getInternalError(){
         return buildStandar(getError("I... I... I don't feel so good ~~mr stark~~...  :thermometer_face: \nPlease contact my developer!").setImage("https://i.imgur.com/anKv8U5.gif"));
     }
 
     public static MessageEmbed buildStandar(EmbedBuilder embedBuilder){
-        return embedBuilder.setFooter(MainBot.url, MainBot.jda.getSelfUser().getAvatarUrl()).setTimestamp(Instant.now()).build();
+        return embedBuilder.setFooter(MainBot.url, MainBot.jda.getSelfUser().getAvatarUrl()).setThumbnail(MainBot.jda.getSelfUser().getAvatarUrl()).setTimestamp(Instant.now()).build();
     }
 
     public static MessageEmbed getUnautorized(){
         return buildStandar(getError("You're not powerful enough to do that slave !").setImage("https://i.imgur.com/0OSsdvW.gif"));
     }
 
+    public static MessageEmbed getHelpList(String role, String list) throws FileNotFoundException {
+        String message = new ResourceLoader().getFile("Help/main.md");
+        message = message.replace("@list", list);
+        return new EmbedBuilder().setTitle("Bot Command ("+role+")").setDescription(message).setFooter("Use '//help <command>' for more info",MainBot.jda.getSelfUser().getAvatarUrl()).setTimestamp(Instant.now()).setColor(Color.green).setThumbnail(MainBot.jda.getSelfUser().getAvatarUrl()).build();
+    }
+
     public static MessageEmbed getLastMessageFromTextChannel(HashMap<String, String> message) {
         EmbedBuilder temp = new EmbedBuilder().setTitle("Channel uses checker").setDescription("Last message date for channels:").setColor(Color.green);
         for(Map.Entry<String, String> entry : message.entrySet()) {
             temp.addField(entry.getKey(),entry.getValue(), false);
         }
+
         return buildStandar(temp);
     }
 
@@ -60,5 +123,18 @@ public class EmbedMessageUtils {
         return new EmbedBuilder().setTitle(":warning: Command error :warning: ").setDescription("").setColor(Color.red).setFooter("'//help move' for more info.", MainBot.jda.getSelfUser().getAvatarUrl()).setTimestamp(Instant.now()).build();
     }
 
+    public static MessageEmbed searchResult(SearchResult result){
+        EmbedBuilder builder = new EmbedBuilder()
+                .setColor(Color.CYAN)
+                .setTitle(result.title)
+                .setImage(result.imageUrl)
+                .addField("Duration: ", result.duration, false)
+                .addField("URL:","https://www.youtube.com/watch?v="+result.id,false)
+                .addField("Chanel:", result.channelTittle, false);
+        return buildStandar(builder);
+    }
+
+
+
 
 }

src/main/java/net/Broken/Tools/FindContentOnWebPage.java

@@ -9,7 +9,6 @@ import java.net.URLConnection;
 public  class FindContentOnWebPage {
     /**
      * Find picture URL on webPage
-     *
      * @param url Web Page URL
      * @param divClass Div class where the picture is
      * @param htmlType HTML tag of image (img)
@@ -33,7 +32,6 @@ public class FindContentOnWebPage {
 
     /**
      * Get source code of web page
-     *
      * @param url Web page URL
      * @return Web page source as String
      * @throws IOException

src/main/java/net/Broken/Tools/LimitChecker.java

@@ -3,7 +3,9 @@ package net.Broken.Tools;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
+
 import java.io.IOException;
+import java.net.HttpURLConnection;
 import java.net.URL;
 
 /**
@@ -15,7 +17,6 @@ public class LimitChecker {
 
     /**
      * Check max page url for web site like baseURL.com/number-2/
-     *
      * @param baseURL Base url without numbers
      * @param minNumber Start number
      * @return max Number
@@ -27,7 +28,8 @@ public class LimitChecker {
         boolean redirected = false;
         Redirection redirection = new Redirection();
 
-        while (!redirected) {
+        while(!redirected )
+        {
             String origin = baseURL+number+suffix;
             String newUrl = redirection.get(origin);
             logger.trace("Origin URL: "+origin+" Result: "+newUrl);
@@ -39,7 +41,8 @@ public class LimitChecker {
         number-=400;
         redirected = false;
         logger.debug("First pass: "+number);
-        while (!redirected) {
+        while(!redirected )
+        {
             String origin = baseURL+number+suffix;
             String newUrl = redirection.get(origin);
             logger.trace("Origin URL: "+origin+" Result: "+newUrl);
@@ -51,7 +54,8 @@ public class LimitChecker {
         number-=90;
         redirected = false;
         logger.debug("Second pass: "+number);
-        while (!redirected) {
+        while(!redirected )
+        {
             String origin = baseURL+number+suffix;
             String newUrl = redirection.get(origin);
             logger.trace("Origin URL: "+origin+" Result: "+newUrl);
@@ -63,7 +67,8 @@ public class LimitChecker {
         number-=9;
         redirected = false;
         logger.debug("Third pass: "+number);
-        while (!redirected) {
+        while(!redirected )
+        {
             String origin = baseURL+number+suffix;
             String newUrl = redirection.get(origin);
             logger.trace("Origin URL: "+origin+" Result: "+newUrl);

src/main/java/net/Broken/Tools/MessageTimeOut.java

@@ -0,0 +1,52 @@
+package net.Broken.Tools;
+
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.exceptions.ErrorResponseException;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Auto dell message util
+ */
+public class MessageTimeOut extends Thread{
+    List<Message> messages;
+    int second;
+    Logger logger = LogManager.getLogger();
+
+    public MessageTimeOut(List<Message> messages, int second) {
+        this.messages = messages;
+        this.second = second;
+    }
+
+    public MessageTimeOut(int second, Message... messages) {
+        this.messages = Arrays.asList(messages);
+        this.second = second;
+    }
+
+    @Override
+    public void run() {
+        logger.debug("Timer for message deletion stated...");
+        for(int i=0; i<second; i++){
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+        logger.debug("Time out! Deleting message!");
+        for(Message aMessage: messages)
+        {
+            try {
+                aMessage.delete().queue();
+            }catch (ErrorResponseException e){
+                logger.warn("Unknown Message");
+            }
+
+        }
+
+    }
+}

src/main/java/net/Broken/Tools/Moderateur.java

@@ -0,0 +1,129 @@
+
+package net.Broken.Tools;
+
+import net.Broken.MainBot;
+
+import net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import net.dv8tion.jda.api.managers.GuildManager;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.ArrayList;
+
+/**
+ * Auto spam utils TODO Rebuild all this shit!
+ */
+public class Moderateur {
+
+    Logger logger = LogManager.getLogger();
+
+    public Moderateur() {}
+
+    // Cette méthode récupère le dernier message est le rajoute à "historique"
+    // SI (spam) retourne 1 (si l'user spam)
+    // SINON     retourne 0
+
+    /**
+     * Get last message and add it on history. After analyse for spam detection
+     * @param user User
+     * @param guild Guild
+     * @param guildManager Guild manager
+     * @param event Message received event
+     * @return 1 if detected as spam, else 0
+     */
+    public int analyse(Member user, Guild guild, GuildManager guildManager, MessageReceivedEvent event){
+
+        ArrayList<Message> thisUserHistory = new ArrayList<>();//Creer tableau pour la copie
+        int i = 0; // variable de parcours de "historique"
+        int nbMessage = 3;
+        int spam = 0;
+
+        if(MainBot.spamUtils.containsKey(user) && MainBot.spamUtils.get(user).isOnSpam()){
+            MainBot.spamUtils.get(user).addMessage(event.getMessage());
+        }
+
+        /********************************************
+         *      si l'USER a deja envoyé un message  *
+         ********************************************/
+        if(MainBot.historique.containsKey(user))// Si le user a deja posté un message
+        {
+            /********************************************
+             * COPIE des infos d"historique" vers TOI[] *
+             ********************************************/
+            thisUserHistory = (ArrayList<Message>) MainBot.historique.get(user).clone();
+
+            /********************************************
+             * Ajout dernier message recu + dans histo' *
+             ********************************************/
+            thisUserHistory.add(0,event.getMessage());
+            if(thisUserHistory.size()>nbMessage+1)
+                thisUserHistory.remove(4);
+            MainBot.historique.put(user, thisUserHistory);// On ajoute dans l'historique TOI
+
+            /*****************************
+             * ANALYSE des messages      *
+             *****************************/
+            int equalCont = 0;
+            String oldMessage = "";
+            for(Message aMessage : thisUserHistory){
+                if(aMessage.getContentRaw().equals(oldMessage))
+                    equalCont++;
+                oldMessage = aMessage.getContentRaw();
+
+            }
+            if(equalCont >= nbMessage){
+                spam = 1;
+                logger.info("Spam detected for "+user.getEffectiveName()+"with 3 identical messages : ");
+                for(Message aMessage : thisUserHistory)
+                {
+                    logger.info("\t - "+aMessage.getContentRaw());
+                }
+                MainBot.historique.put(user, new ArrayList<Message>());
+            }
+
+        } else {
+            /********************************************
+             * SI c'est le 1er message de l'USER       *
+             ********************************************/
+            // si le user n'a pas encore posté de message
+            // on ajoute le dernier message dans "historique"
+            thisUserHistory.add(0,event.getMessage());
+
+            MainBot.historique.put(user, thisUserHistory);
+        }
+        /**********************************
+         * AFFICHAGE DE HISTORIQUE        *
+         **********************************/
+
+
+
+
+        /********************************************
+         *      Comptage du nombre de message       *
+         ********************************************/
+        if(MainBot.message_compteur.containsKey(user))// Si le user a deja posté un message
+        {
+            int cpt = MainBot.message_compteur.get(user);
+            cpt++;
+            //System.out.println("compteur : "+cpt);
+            MainBot.message_compteur.put(user, cpt);
+            if(cpt > 5){
+                MainBot.message_compteur.put(user,0);
+                spam = 1;
+                logger.info("Spam detected for "+user.getEffectiveName()+"with 5 messages in 5 secondes: ");
+                ArrayList<Message> histo = MainBot.historique.get(user);
+                for (Message aMessage:histo )
+                {
+//                   logger.debug("\t*"+aMessage.getContent());
+                }
+            }
+        }else{
+            MainBot.message_compteur.put(user, 1);
+        }
+
+        return spam;
+    }
+}

src/main/java/net/Broken/Tools/PrivateMessage.java

@@ -0,0 +1,36 @@
+package net.Broken.Tools;
+
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.MessageEmbed;
+import net.dv8tion.jda.api.entities.User;
+import org.apache.logging.log4j.Logger;
+
+/**
+ * Private message utils
+ */
+public class PrivateMessage {
+
+    /**
+     * Auto open private channel and send message
+     * @param user User to send message
+     * @param message Message to send
+     * @param logger Logger
+     */
+    public static void send(User user, String message, Logger logger){
+
+        user.openPrivateChannel().complete().sendMessage(message).queue();
+
+    }
+
+    /**
+     * Auto open private channel and send message
+     * @param user User to send message
+     * @param message Message to send
+     * @param logger Logger
+     * @return Sended Message
+     */
+    public static Message send(User user, MessageEmbed message, Logger logger){
+        return user.openPrivateChannel().complete().sendMessage(message).complete();
+
+    }
+}

src/main/java/net/Broken/Tools/Redirection.java

@@ -4,6 +4,7 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.net.HttpURLConnection;
 import java.net.URL;
+import java.net.URLConnection;
 
 /**
  * Redirection URL Util
@@ -15,7 +16,6 @@ public class Redirection {
 
     /**
      * Return Redirected URL
-     *
      * @param urlString Source URL
      * @return Redirected URL
      * @throws IOException
@@ -39,4 +39,5 @@ public class Redirection {
     }
 
 
+
 }

src/main/java/net/Broken/Tools/ResourceLoader.java

@@ -3,18 +3,20 @@ package net.Broken.Tools;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
+import java.io.File;
 import java.io.FileNotFoundException;
+import java.io.IOException;
 import java.io.InputStream;
 import java.util.Scanner;
 
 
+
 public class ResourceLoader {
 
     private Logger logger = LogManager.getLogger();
 
     /**
      * Get file contents as string for resource folder
-     *
      * @param fileName Requested file
      * @return File contents as string
      * @throws FileNotFoundException

src/main/java/net/Broken/Tools/SettingsUtils.java

@@ -17,14 +17,22 @@ import org.apache.logging.log4j.Logger;
 import org.springframework.context.ApplicationContext;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 public class SettingsUtils {
 
     private static SettingsUtils INSTANCE;
     private final Logger logger = LogManager.getLogger();
+
+    public static SettingsUtils getInstance() {
+        return (INSTANCE == null) ? new SettingsUtils() : INSTANCE;
+    }
+
     private final GuildPreferenceRepository guildPreferenceRepository;
     private final UserRepository userRepository;
+
+
     private SettingsUtils() {
         ApplicationContext context = SpringContext.getAppContext();
         guildPreferenceRepository = (GuildPreferenceRepository) context.getBean("guildPreferenceRepository");
@@ -33,10 +41,6 @@ public class SettingsUtils {
 
     }
 
-    public static SettingsUtils getInstance() {
-        return (INSTANCE == null) ? new SettingsUtils() : INSTANCE;
-    }
-
     /**
      * Extract all settings for displaying on webpage
      *

src/main/java/net/Broken/Tools/TableRenderer.java

@@ -1,13 +1,13 @@
 package net.Broken.Tools;
 
-import org.apache.commons.lang3.StringUtils;
-
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
+import org.apache.commons.lang3.StringUtils;
+
 /**
  * Utils to render table in block code
  */
@@ -25,7 +25,6 @@ public class TableRenderer {
 
     /**
      * Set Table header(s)
-     *
      * @param header Header(s) as String
      */
     public void setHeader(Object... header) {
@@ -36,7 +35,6 @@ public class TableRenderer {
 
     /**
      * Add row to table
-     *
      * @param content Content(s) as string
      */
     public void addRow(Object... content) {
@@ -48,7 +46,6 @@ public class TableRenderer {
 
     /**
      * Change default empty string
-     *
      * @param str
      */
     public void setEmptyString(String str) {

src/main/java/net/Broken/Tools/TimeConvertor.java

@@ -3,11 +3,14 @@ package net.Broken.Tools;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
 import java.util.ArrayList;
+import java.util.Date;
+import java.util.concurrent.TimeUnit;
 
 public class TimeConvertor {
     static Logger logger = LogManager.getLogger();
-
     public static ArrayList<String> sToTime(long sec){
         final int MINUTES_IN_AN_HOUR = 60;
         final int SECONDS_IN_A_MINUTE = 60;

src/main/java/net/Broken/Tools/TrueRandom.java

@@ -9,6 +9,7 @@ import org.apache.http.entity.StringEntity;
 import org.apache.http.impl.client.HttpClientBuilder;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.json.JSONArray;
 import org.json.JSONObject;
 
 import java.io.IOException;
@@ -19,16 +20,19 @@ import java.util.List;
 public class TrueRandom {
 
     private static TrueRandom INSTANCE = new TrueRandom();
-    private Logger logger = LogManager.getLogger();
-    private String url = "https://api.random.org/json-rpc/2/invoke";
-    private String apiKey = System.getenv("RANDOM_API_KEY");
-    private TrueRandom() {
-    }
 
     public static TrueRandom getINSTANCE() {
         return INSTANCE;
     }
 
+    private Logger logger = LogManager.getLogger();
+
+    private String url = "https://api.random.org/json-rpc/2/invoke";
+    private String apiKey = System.getenv("RANDOM_API_KEY");
+
+    private TrueRandom() {
+    }
+
     public ArrayList<Integer> getNumbers(int min, int max) throws IOException {
         HttpClient httpClient = HttpClientBuilder.create().build();
 
@@ -48,6 +52,7 @@ public class TrueRandom {
         }
 
 
+
         InputStream responseIS = response.getEntity().getContent();
         String content = IOUtils.toString(responseIS, "UTF-8");
         logger.trace(content);

src/main/java/net/Broken/Tools/UserManager/Oauth.java

@@ -18,13 +18,13 @@ import java.util.List;
 
 public class Oauth {
     private static Oauth INSTANCE = new Oauth();
+    public static Oauth getInstance(){ return INSTANCE; }
+
     Logger logger = LogManager.getLogger();
     private String baseUrl = "https://discordapp.com/api";
     private String mePath = "/users/@me";
 
-    public static Oauth getInstance() {
-        return INSTANCE;
-    }
+
 
     private JSONObject getUserId(String token){
         StringBuffer content = new StringBuffer();

src/main/java/net/Broken/Tools/UserManager/PasswordResetUtils.java

@@ -15,12 +15,13 @@ import org.springframework.security.crypto.password.PasswordEncoder;
 import java.util.List;
 
 public class PasswordResetUtils {
-    private static PasswordResetUtils INSTANCE = new PasswordResetUtils();
     private Logger logger = LogManager.getLogger();
     private PasswordEncoder passwordEncoder;
     private PendingPwdResetRepository pendingPwdResetRepository;
     private UserRepository userRepository;
 
+    private static PasswordResetUtils INSTANCE = new PasswordResetUtils();
+
     /**
      * Private default constructor
      */
@@ -34,7 +35,6 @@ public class PasswordResetUtils {
 
     /**
      * Singleton
-     *
      * @return Unique PasswordResetUtils instance
      */
     public static PasswordResetUtils getInstance(){

src/main/java/net/Broken/Tools/UserManager/UserUtils.java

@@ -7,6 +7,7 @@ import net.Broken.DB.Repository.UserRepository;
 import net.Broken.MainBot;
 import net.Broken.RestApi.Data.UserManager.UserInfoData;
 import net.Broken.Tools.EmbedMessageUtils;
+import net.Broken.Tools.PrivateMessage;
 import net.Broken.Tools.ResourceLoader;
 import net.Broken.Tools.UserManager.Exceptions.*;
 import net.dv8tion.jda.api.entities.MessageEmbed;
@@ -22,26 +23,128 @@ import java.util.UUID;
 
 public class UserUtils {
 
-    private static UserUtils INSTANCE = new UserUtils();
     private Logger logger = LogManager.getLogger();
 
+    private static UserUtils INSTANCE = new UserUtils();
+
     /**
      * Private default constructor
      */
-    private UserUtils() {
-    }
+    private UserUtils(){}
 
     /**
      * Singleton
-     *
      * @return Unique UserUtils instance
      */
     public static UserUtils getInstance(){
         return INSTANCE;
     }
+
+
+    /**
+     * Check if user exist on Guild, if exist, generate and send checkTocken, create entry on PendingUser DB
+     * @param pendingUserRepository Pending user DB interface
+     * @param userRepository User DB interface
+     * @param passwordEncoder Password encoder
+     * @param userInfo Received data
+     * @return PendingUserEntity PK
+     * @throws UserNotFoundException User not found in guild
+     * @throws PasswordNotMatchException User already registered in PendingUser DB but password not match
+     * @throws UserAlreadyRegistered User already registered in User DB
+     */
+    public String sendCheckToken(PendingUserRepository pendingUserRepository, UserRepository userRepository, PasswordEncoder passwordEncoder, UserInfoData userInfo) throws UserNotFoundException, PasswordNotMatchException, UserAlreadyRegistered {
+
+        logger.info("New registration for " + userInfo.name);
+
+        List<User> users = MainBot.jda.getUsersByName(userInfo.name,true);
+        if(users.size() < 1)
+            throw new UserNotFoundException();
+
+        User user = users.get(0);
+        logger.info("User found!");
+
+        PendingUserEntity pendingUserEntity = null;
+        String token = "";
+
+        //Preference if exist on register user
+        if(userRepository.findByJdaId(user.getId()).size() > 0){
+            logger.warn("User already registered!");
+            throw new UserAlreadyRegistered();
+        }
+
+
+
+        //Check if exist in pading user Table
+        List<PendingUserEntity> pendingUsers = pendingUserRepository.findByJdaId(user.getId());
+        if(pendingUsers.size() != 0){
+            PendingUserEntity thisUser = pendingUsers.get(0);
+            if(passwordEncoder.matches(userInfo.password, thisUser.getPassword())){
+                logger.info("Password matches");
+                pendingUserEntity = thisUser;
+                token = thisUser.getCheckToken();
+            }else{
+                logger.warn("Password don't match!");
+                throw new PasswordNotMatchException();
+            }
+        }
+
+
+
+        logger.info("Generating check Token...");
+        if(token.equals("")){
+            token = generateCheckToken();
+        }
+
+        logger.info("Token generated: " + token);
+        if(pendingUserEntity == null) {
+            pendingUserEntity = new PendingUserEntity(user.getName(), user.getId(), token, passwordEncoder.encode(userInfo.password));
+            pendingUserEntity = pendingUserRepository.save(pendingUserEntity);
+        }
+
+        String message = null;
+        try {
+            message = new ResourceLoader().getFile("MessagesTemplates/RegisterMessage.md");
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+
+        message = message.replace("%code",token);
+
+        MessageEmbed ebM = EmbedMessageUtils.getRegister(message);
+        PrivateMessage.send(user,ebM,logger);
+        return pendingUserEntity.getId().toString();
+        
+    }
+
+    /**
+     * Confirm user account
+     * @param pendingUserRepository Pending user DB interface
+     * @param id UserPendingEntity PK to cofirm
+     * @param checkToken received token
+     * @return PendingUserEntity
+     * @throws TokenNotMatch Given token not match
+     * @throws UserNotFoundException User not found in Pending user DB
+     */
+    public PendingUserEntity confirmCheckToken(PendingUserRepository pendingUserRepository, int id, String checkToken ) throws TokenNotMatch, UserNotFoundException {
+        PendingUserEntity pendingUser = pendingUserRepository.findById(id);
+        if(pendingUser != null) {
+            if(pendingUser.getCheckToken().equals(checkToken)){
+                logger.info("Check Token match!");
+            }
+            else{
+                logger.warn("Check token not match!");
+                throw new TokenNotMatch();
+            }
+        }
+        else{
+            logger.warn("Id not Found!");
+            throw new UserNotFoundException();
+        }
+        return pendingUser;
+    }
+
     /**
      * Get user Entity
-     *
      * @param userRepository User DB interface
      * @param passwordEncoder Password encoder
      * @param userInfoData Received data
@@ -54,12 +157,15 @@ public class UserUtils {
         if(users.size()<1){
             logger.warn("Login with unknown username: " + userInfoData.name);
             throw new UserNotFoundException();
-        } else {
+        }
+        else{
             UserEntity user = users.get(0);
             if(passwordEncoder.matches(userInfoData.password,user.getPassword())){
                 logger.info("Login successful for " + user.getName());
                 return user;
-            } else {
+            }
+            else
+            {
                 logger.warn("Login fail for " + user.getName() + ", wrong password!");
                 throw new PasswordNotMatchException();
             }
@@ -68,7 +174,6 @@ public class UserUtils {
 
     /**
      * return token's UserEntity
-     *
      * @param userRepository User DB interface
      * @param token Received token
      * @return User Entity
@@ -78,14 +183,14 @@ public class UserUtils {
         List<UserEntity> users = userRepository.findByApiToken(token);
         if(users.size() > 0){
             return users.get(0);
-        } else
+        }
+        else
             throw new UnknownTokenException();
 
     }
 
     /**
      * Generate API Token
-     *
      * @return UUID String TODO Find something more secure
      */
     public String generateApiToken(){
@@ -94,7 +199,6 @@ public class UserUtils {
 
     /**
      * Generate short check token
-     *
      * @return check token as string
      */
     public String generateCheckToken(){

src/main/java/net/Broken/Tools/UserSpamUtils.java

@@ -0,0 +1,69 @@
+package net.Broken.Tools;
+
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.Message;
+
+import java.util.List;
+
+/**
+ * Spam info for one user
+ */
+public class UserSpamUtils {
+    private AntiSpam.Minuteur minuteur;
+    private Member user;
+    private int multip = 0;
+    private boolean onSpam = false;
+    private List<Message> messages;
+
+    public int getTimeLeft(){
+        return minuteur.timeLeft;
+    }
+
+    public int getMultip()
+    {
+        return multip;
+    }
+
+    public UserSpamUtils(Member user, List<Message> messages) {
+        this.user = user;
+        this.messages = messages;
+    }
+
+
+    public void setMinuteur(AntiSpam.Minuteur minuteur) {
+        this.minuteur = minuteur;
+    }
+
+    public void launchMinuteur(){
+        minuteur.start();
+    }
+
+    public void setMultip(int multip) {
+        this.multip = multip;
+    }
+
+    public boolean isOnSpam() {
+        return onSpam;
+    }
+
+    public void setOnSpam(boolean onSpam) {
+        this.onSpam = onSpam;
+    }
+
+    public Member getUser() {
+        return user;
+    }
+
+    public void addMessage(Message message){
+        messages.add(message);
+    }
+
+    public List<Message> getMessages() {
+        return messages;
+    }
+
+    public void clearAndAdd(Message message){
+        messages.clear();
+        messages.add(message);
+    }
+}

src/main/java/net/Broken/audio/AudioM.java

@@ -17,6 +17,7 @@ import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.entities.User;
 import net.dv8tion.jda.api.entities.VoiceChannel;
 import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -26,7 +27,6 @@ import java.util.List;
 
 public class AudioM {
 
-    private static HashMap<Guild, AudioM> INSTANCES = new HashMap<>();
     /**
      * Music manager for this guild
      */
@@ -53,12 +53,7 @@ public class AudioM {
     private Guild guild;
     private Logger logger = LogManager.getLogger();
 
-    private AudioM(Guild guild) {
-        this.playerManager = new DefaultAudioPlayerManager();
-        AudioSourceManagers.registerRemoteSources(playerManager);
-        AudioSourceManagers.registerLocalSource(playerManager);
-        this.guild = guild;
-    }
+    private static HashMap<Guild, AudioM> INSTANCES = new HashMap<>();
 
     public static AudioM getInstance(Guild guild) {
         if (!INSTANCES.containsKey(guild)) {
@@ -68,6 +63,14 @@ public class AudioM {
         return INSTANCES.get(guild);
     }
 
+
+    private AudioM(Guild guild) {
+        this.playerManager = new DefaultAudioPlayerManager();
+        AudioSourceManagers.registerRemoteSources(playerManager);
+        AudioSourceManagers.registerLocalSource(playerManager);
+        this.guild = guild;
+    }
+
     /**
      * Load audio track from url, connect to chanel if not connected
      *
@@ -104,7 +107,7 @@ public class AudioM {
             public void noMatches() {
                 logger.warn("[" + guild + "] Cant find media!");
                 Message message = new MessageBuilder().setEmbeds(EmbedMessageUtils.getMusicError("Video not found !")).build();
-                event.getHook().setEphemeral(true).sendMessage(message).queue();
+                event.getHook().sendMessage(message).queue();
             }
 
             @Override
@@ -112,7 +115,7 @@ public class AudioM {
                 logger.error("[" + guild + "] Can't load media!");
                 logger.error(exception.getMessage());
                 Message message = new MessageBuilder().setEmbeds(EmbedMessageUtils.getMusicError("Playback error !")).build();
-                event.getHook().setEphemeral(true).sendMessage(message).queue();
+                event.getHook().sendMessage(message).queue();
             }
         });
     }
@@ -293,7 +296,7 @@ public class AudioM {
             loadAndPlay(event, playedChanel, url, playListLimit, onHead);
         } else {
             Message message = new MessageBuilder().setEmbeds(EmbedMessageUtils.getMusicError("Not connected to vocal chanel !")).build();
-            event.getHook().setEphemeral(true).sendMessage(message).queue();
+            event.getHook().sendMessage(message).queue();
         }
     }
 

src/main/java/net/Broken/audio/AudioPlayerSendHandler.java

@@ -1,6 +1,7 @@
 package net.Broken.audio;
 
 import com.sedmelluq.discord.lavaplayer.player.AudioPlayer;
+import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame;
 import com.sedmelluq.discord.lavaplayer.track.playback.MutableAudioFrame;
 import net.dv8tion.jda.api.audio.AudioSendHandler;
 

src/main/java/net/Broken/audio/GuildMusicManager.java

@@ -21,7 +21,6 @@ public class GuildMusicManager {
 
     /**
      * Creates a player and a track scheduler.
-     *
      * @param manager Audio player manager to use for creating the player.
      */
     public GuildMusicManager(AudioPlayerManager manager, Guild guild) {

src/main/java/net/Broken/audio/Playlist/PlaylistManager.java

@@ -27,15 +27,24 @@ import java.util.List;
 
 public class PlaylistManager {
 
-    private static PlaylistManager INSTANCE = new PlaylistManager();
     private final ResponseEntity<PlaylistResponseData> TOKEN_ERROR = new ResponseEntity<>(new PlaylistResponseData("Unknown Token!\nPlease Re-connect.", "token"), HttpStatus.UNAUTHORIZED);
+
     private final ResponseEntity<PlaylistResponseData> PLAYLIST_NOT_FOUND = new ResponseEntity<>(new PlaylistResponseData("Playlist not found", "playlist"), HttpStatus.NOT_FOUND);
+
     private final ResponseEntity<PlaylistResponseData> TRACK_NOT_FOUND = new ResponseEntity<>(new PlaylistResponseData("Can't find media!", "track"), HttpStatus.NOT_FOUND);
-    Logger logger = LogManager.getLogger();
+
+
+
     private PlaylistRepository playlistRepository;
+
     private TrackRepository trackRepository;
+
     private UserRepository userRepository;
 
+    Logger logger = LogManager.getLogger();
+
+    private static PlaylistManager INSTANCE = new PlaylistManager();
+
     private PlaylistManager() {
         ApplicationContext context = SpringContext.getAppContext();
 
@@ -62,7 +71,9 @@ public class PlaylistManager {
 
             if(webLoadUtils.userAudioTrack == null){
                 return TRACK_NOT_FOUND;
-            } else {
+            }
+            else
+            {
                 TrackEntity trackEntity = new TrackEntity(webLoadUtils.userAudioTrack.getAudioTrack().getInfo(), data.pos, playlist);
 
                 playlist = insert(playlist, trackEntity);
@@ -70,6 +81,7 @@ public class PlaylistManager {
             }
 
 
+
         } catch (UnknownTokenException e) {
             logger.warn("Unknown token: "+ token);
             return TOKEN_ERROR;
@@ -87,11 +99,13 @@ public class PlaylistManager {
             PlaylistEntity playlist = getPlaylist(data.playlistId);
 
 
+
             TrackEntity toDelete = trackRepository.findById(data.id);
 
             playlist = remove(playlist, toDelete);
 
-            if (playlist == null) {
+            if(playlist == null)
+            {
                 logger.warn("Playlist: " + data.playlistId + " Track: " + data.id);
                 return TRACK_NOT_FOUND;
             }
@@ -114,13 +128,15 @@ public class PlaylistManager {
             PlaylistEntity playlist = getPlaylist(data.playlistId);
 
 
+
             TrackEntity toMove = trackRepository.findById(data.id);
 
             TrackEntity save = new TrackEntity(toMove);
 
             playlist = remove(playlist, toMove);
 
-            if (playlist == null) {
+            if(playlist == null)
+            {
                 logger.warn("Playlist: " + data.playlistId + " Track: " + data.id);
                 return TRACK_NOT_FOUND;
             }
@@ -130,6 +146,7 @@ public class PlaylistManager {
             playlist = insert(playlist, save);
 
 
+
             return new ResponseEntity<>(new PlaylistResponseData("Ok", playlist),HttpStatus.OK);
 
         } catch (UnknownTokenException e) {
@@ -169,7 +186,8 @@ public class PlaylistManager {
             }
         }
 
-        if (!increase) {
+        if(!increase)
+        {
             trackEntity.setPos(tracks.size());
         }
 

src/main/java/net/Broken/audio/TrackScheduler.java

@@ -205,12 +205,12 @@ public class TrackScheduler extends AudioEventAdapter {
         }
     }
 
-    public boolean isAutoFlow() {
-        return autoFlow;
-    }
-
     public void setAutoFlow(boolean autoFlow) {
         this.autoFlow = autoFlow;
         needAutoPlay();
     }
+
+    public boolean isAutoFlow() {
+        return autoFlow;
+    }
 }

src/main/java/net/Broken/audio/WebLoadUtils.java

@@ -18,13 +18,12 @@ import org.springframework.http.ResponseEntity;
  * Interface between WebApi and Music bot for submitting track
  */
 public class WebLoadUtils {
-    public UserAudioTrack userAudioTrack;
     private ResponseEntity<CommandResponseData> response;
     private Logger logger = LogManager.getLogger();
+    public UserAudioTrack userAudioTrack;
 
     /**
      * Submit a track or playlist to Music bot
-     *
      * @param data Received data from API
      * @param user User who submit the track
      * @param guild
@@ -50,11 +49,13 @@ public class WebLoadUtils {
                 @Override
                 public void playlistLoaded(AudioPlaylist playlist) {
 
-                    if (submit) {
+                    if(submit)
+                    {
                         logger.info("Playlist detected from web! Limit: " + data.playlistLimit);
                         audioM.playListLoader(playlist, data.playlistLimit, user, data.onHead);
                         response = new ResponseEntity<>(new CommandResponseData("ADD", "Loaded"), HttpStatus.OK);
-                    } else {
+                    }else
+                    {
                         response = new ResponseEntity<>(new CommandResponseData("ADD", "Adding a list on saved playlist is currently not supported"), HttpStatus.NOT_ACCEPTABLE);
 
                     }
@@ -85,7 +86,6 @@ public class WebLoadUtils {
 
     /**
      * Wait for the end of submit process and return ResponseEntity
-     *
      * @return HTTP Response
      */
     public ResponseEntity<CommandResponseData> getResponse(){

src/main/java/net/Broken/audio/Youtube/YoutubeSearchRework.java

@@ -2,6 +2,7 @@ package net.Broken.audio.Youtube;
 
 import com.sedmelluq.discord.lavaplayer.source.youtube.YoutubeAudioTrack;
 import com.sedmelluq.discord.lavaplayer.source.youtube.YoutubeSearchProvider;
+import com.sedmelluq.discord.lavaplayer.track.AudioItem;
 import com.sedmelluq.discord.lavaplayer.track.AudioTrack;
 import com.sedmelluq.discord.lavaplayer.track.BasicAudioPlaylist;
 import org.apache.logging.log4j.LogManager;
@@ -20,9 +21,10 @@ import java.util.concurrent.TimeUnit;
 
 public class YoutubeSearchRework {
 
-    private static YoutubeSearchRework INSTANCE;
     private Logger logger = LogManager.getLogger();
 
+    private static YoutubeSearchRework INSTANCE;
+
     public static YoutubeSearchRework getInstance() {
         if (INSTANCE == null) {
             INSTANCE = new YoutubeSearchRework();

src/main/java/net/Broken/audio/Youtube/YoutubeTools.java

@@ -3,8 +3,8 @@ package net.Broken.audio.Youtube;
 import com.google.api.client.http.javanet.NetHttpTransport;
 import com.google.api.client.json.gson.GsonFactory;
 import com.google.api.services.youtube.YouTube;
-import com.google.api.services.youtube.model.SearchResult;
 import com.google.api.services.youtube.model.*;
+import com.google.api.services.youtube.model.SearchResult;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -13,12 +13,15 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 
+import static org.hibernate.engine.jdbc.Size.LobMultiplier.M;
+
 public class YoutubeTools {
 
-    private static YoutubeTools INSTANCE;
     private Logger logger = LogManager.getLogger();
     private String apiKey = System.getenv("GOOGLE_API_KEY");
 
+    private static YoutubeTools INSTANCE;
+
     private YoutubeTools() {
 
     }
@@ -46,6 +49,8 @@ public class YoutubeTools {
         YouTube youtube = getYoutubeService();
 
 
+
+
         YouTube.Search.List searchListRelatedVideosRequest = youtube.search().list(Collections.singletonList("snippet"));
         searchListRelatedVideosRequest.setRelatedToVideoId(videoId);
         searchListRelatedVideosRequest.setType(Collections.singletonList("video"));
@@ -105,7 +110,8 @@ public class YoutubeTools {
 
             }
             return finalResult;
-        } else {
+        }
+        else{
             for(SearchResult item : response.getItems()){
                 idString.append(item.getId().getVideoId()).append(",");
             }
@@ -126,6 +132,13 @@ public class YoutubeTools {
         }
 
 
+
+
+
+
+
+
+
     }
 
 
@@ -142,7 +155,8 @@ public class YoutubeTools {
             String matched = time.substring(0, time.indexOf("H")+1);
             time = time.replace(matched,"");
             hours = Integer.parseInt(matched.replace("H", ""));
-        } else
+        }
+        else
             hours = 0;
         logger.trace(time);
 
@@ -151,7 +165,8 @@ public class YoutubeTools {
             String matched = time.substring(0, time.indexOf("M")+1);
             time = time.replace(matched,"");
             minutes = Integer.parseInt(matched.replace("M", ""));
-        } else
+        }
+        else
             minutes = 0;
         logger.trace(time);
         if(time.contains("S")) {
@@ -159,7 +174,8 @@ public class YoutubeTools {
             String matched = time.substring(0, time.indexOf("S")+1);
             time = time.replace(matched,"");
             seconds = Integer.parseInt(matched.replace("S", ""));
-        } else
+        }
+        else
             seconds = 0;
         logger.trace(time);
 

src/main/java/net/Broken/webView/GeneralWebView.java

@@ -22,6 +22,7 @@ import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.ResponseStatus;
 
+
 import javax.servlet.http.Cookie;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
@@ -45,31 +46,11 @@ public class GeneralWebView {
         this.userRepository = userRepository;
     }
 
-    public static Model addGuildAndRedirect(Model model, String token, String guildId, User user) {
-        List<Guild> mutualGuilds = user.getMutualGuilds();
-        Integer lastCount = MainBot.mutualGuildCount.get(user.getId());
-        if (lastCount == null || lastCount != mutualGuilds.size()) {
-            LogManager.getLogger().debug("Guild miss match, re-cache users...");
-            CacheTools.loadAllGuildMembers();
-            mutualGuilds = user.getMutualGuilds();
-            MainBot.mutualGuildCount.put(user.getId(), mutualGuilds.size());
+
+    @ResponseStatus(HttpStatus.FORBIDDEN)
+    public class ForbiddenException extends RuntimeException {
     }
 
-        Guild guild = MainBot.jda.getGuildById(guildId);
-        if (guild != null) {
-            model.addAttribute("guild_name", guild.getName());
-            model.addAttribute("guild_id", guild.getId());
-            model.addAttribute("guild_icon", guild.getIconUrl() == null ? "https://discordapp.com/assets/dd4dbc0016779df1378e7812eabaa04d.png" : guild.getIconUrl());
-            model.addAttribute("mutual_guilds", mutualGuilds);
-            model.addAttribute("isAdmin", SettingsUtils.getInstance().checkPermission(token, guildId));
-        } else {
-            model.addAttribute("guild_name", "");
-            model.addAttribute("guild_icon", "");
-        }
-
-        model.addAttribute("redirect_url", System.getenv("OAUTH_URL"));
-        return model;
-    }
 
     @RequestMapping("/")
     public String music(Model model, HttpServletResponse response, HttpServletRequest request, @CookieValue(value = "guild", defaultValue = "1") String guildId, @CookieValue(value = "token", defaultValue = "") String token) {
@@ -199,8 +180,31 @@ public class GeneralWebView {
 
     }
 
-    @ResponseStatus(HttpStatus.FORBIDDEN)
-    public class ForbiddenException extends RuntimeException {
+
+    public static Model addGuildAndRedirect(Model model, String token, String guildId, User user) {
+        List<Guild> mutualGuilds = user.getMutualGuilds();
+        Integer lastCount = MainBot.mutualGuildCount.get(user.getId());
+        if (lastCount == null || lastCount != mutualGuilds.size()) {
+            LogManager.getLogger().debug("Guild miss match, re-cache users...");
+            CacheTools.loadAllGuildMembers();
+            mutualGuilds = user.getMutualGuilds();
+            MainBot.mutualGuildCount.put(user.getId(), mutualGuilds.size());
+        }
+
+        Guild guild = MainBot.jda.getGuildById(guildId);
+        if (guild != null) {
+            model.addAttribute("guild_name", guild.getName());
+            model.addAttribute("guild_id", guild.getId());
+            model.addAttribute("guild_icon", guild.getIconUrl() == null ? "https://discordapp.com/assets/dd4dbc0016779df1378e7812eabaa04d.png" : guild.getIconUrl());
+            model.addAttribute("mutual_guilds", mutualGuilds);
+            model.addAttribute("isAdmin", SettingsUtils.getInstance().checkPermission(token, guildId));
+        } else {
+            model.addAttribute("guild_name", "");
+            model.addAttribute("guild_icon", "");
+        }
+
+        model.addAttribute("redirect_url", System.getenv("OAUTH_URL"));
+        return model;
     }
 
 

src/main/java/net/Broken/webView/MusicWebView.java

@@ -37,6 +37,7 @@ public class MusicWebView {
     }
 
 
+
     @RequestMapping("/music")
     public String music(Model model, HttpServletResponse response, HttpServletRequest request, @CookieValue(value = "guild", defaultValue = "1") String guildId, @CookieValue(value = "token", defaultValue = "") String token){
         if(token.equals("")){
@@ -74,5 +75,6 @@ public class MusicWebView {
         }
 
 
+
     }
 }

src/main/java/net/Broken/webView/MvcApplication.java

@@ -25,7 +25,6 @@ public class MvcApplication implements WebMvcConfigurer {
                 .resourceChain(true)
                 .addResolver(versionResourceResolver);
     }
-
     @Bean
     public ResourceUrlEncodingFilter resourceUrlEncodingFilter() {
         return new ResourceUrlEncodingFilter();

src/main/java/net/Broken/webView/MyErrorController.java

@@ -29,9 +29,11 @@ public class MyErrorController implements ErrorController {
 
             if(statusCode == HttpStatus.NOT_FOUND.value()) {
                 return "error/404";
-            } else if (statusCode == HttpStatus.FORBIDDEN.value()) {
+            }
+            else if(statusCode == HttpStatus.FORBIDDEN.value()){
                 return "error/403";
-            } else if (statusCode == HttpStatus.INTERNAL_SERVER_ERROR.value()) {
+            }
+            else if(statusCode == HttpStatus.INTERNAL_SERVER_ERROR.value()){
                 return "error/500";
             }
 

src/main/resources/Help/Cat/en/main.md

@@ -0,0 +1,4 @@
+
+Hey look! A cat!
+And he's different everytime !
+That is so cute! :cat:

src/main/resources/Help/Cat/fr/main.md

@@ -0,0 +1,4 @@
+
+Ho! Regarde! Un chat!
+Mais il est different à chaque fois en plus!
+C'est trop cute! :cat:

src/main/resources/Help/ChannelsReview/en/main.md

@@ -0,0 +1,5 @@
+This command allow you to see which text channel is used by 
+returning the date from the last message sent in every text channel.
+
+You can add a date in the format "day.month.year" to return channels
+that don't have new message since this date.

src/main/resources/Help/ChannelsReview/fr/main.md

@@ -0,0 +1,6 @@
+Cette commande permet de verifier quels channels textes ne sont
+pas utilisés en remontant la date du dernier message envoyé 
+dans tout les channels.
+
+Vous pouvez ajouter une date au format "jour.mois.année" pour remonter les channels
+qui n'ont pas eu de message depuis avant cette date.

src/main/resources/Help/Default/en/main.md

@@ -0,0 +1,2 @@
+This command doesn't have any help at the moment.
+To help us improve: https://github.com/BrokenFire/BrokenDiscordBot

src/main/resources/Help/Default/fr/main.md

@@ -0,0 +1,2 @@
+L'aide pour cette commande n'est pas encore disponible !
+Pour contribué: https://github.com/BrokenFire/BrokenDiscordBot

src/main/resources/Help/Flush/en/main.md

@@ -0,0 +1,3 @@
+
+`//flush <number>`
+:arrow_right:	*Erase the n last posts (Max = 100)*

src/main/resources/Help/Flush/fr/main.md

@@ -0,0 +1,3 @@
+
+`//flush <nbr>`
+:arrow_right:	*Efface les n derniers messages (Max = 100)*

src/main/resources/Help/Move/en/main.md

@@ -0,0 +1,2 @@
+`//move <@user> <@targeted_role>`
+:arrow_right: *Move an user to the targeted role.*

src/main/resources/Help/Move/fr/main.md

@@ -0,0 +1,2 @@
+`//move <@utilisateur> <@rôleCible>`
+:arrow_right: *Deplacement d'un utilisateur vers un rôle cible, attention à bien faire les mentions.*

src/main/resources/Help/Music/en/main.md

@@ -0,0 +1,26 @@
+`//music play <url>`
+:arrow_right:	*Let's dance! Sets the vocal chat to use.*
+
+`//music pause`
+:arrow_right:	*Pause the current track.*
+
+`//music resume`
+:arrow_right:	*Resume the current track.*
+
+`//music next`
+:arrow_right:	*Skip the current track.*
+
+`//music stop`
+:arrow_right:	*Stop the current track and empty the playlist.*
+
+`//music info`
+:arrow_right:	*Show info of the current track.*
+
+`//music flush`
+:arrow_right:	*Delete the current playlist.*
+
+`//music list`
+:arrow_right:	*Show information of the current playlist.*
+
+`//music add(Next) <url>`
+:arrow_right:	*Add the url to the current playlist.*

src/main/resources/Help/Music/fr/main.md

@@ -0,0 +1,26 @@
+`//music play <url>`
+:arrow_right:	*Let's dance! Definit le chat vocal à utiliser.*
+
+`//music pause`
+:arrow_right:	*Mise en pause de la piste en cours.*
+
+`//music resume`
+:arrow_right:	*Reprise de la lecture de la piste en cours.*
+
+`//music next`
+:arrow_right:	*Change la piste en cours.*
+
+`//music stop`
+:arrow_right:	*Arrête la piste en cours et supprime la playlist.*
+
+`//music info`
+:arrow_right:	*Affiche les infos de la piste en cours.*
+
+`//music flush`
+:arrow_right:	*Supprime la playlist en cours.*
+
+`//music list`
+:arrow_right:	*Affiche la playlist en cours.*
+
+`//music add(Next) <url>`
+:arrow_right:	*Ajoute l'url à la playlist en cours.*