From 0094701c2a229104545bfec09d5b3cde56004673 Mon Sep 17 00:00:00 2001 From: Mysaa Date: Sun, 23 May 2021 02:34:31 +0200 Subject: [PATCH 1/3] Modification de l'api et de l'internaddon --- .../com/bernard/juliabot/CommandCalled.java | 59 ++++ .../bernard/juliabot/CommandeSurchargee.java | 87 +++++ .../com/bernard/juliabot/api/CCommande.java | 9 + .../juliabot/api/CommandArguments.java | 45 +++ .../juliabot/api/DiscordCCommande.java | 19 ++ .../bernard/juliabot/api/StringCCommande.java | 9 + .../com/bernard/juliabot/api/Trukilie.java | 13 + .../juliabot/internaddon/Internaddon.java | 297 ++++++++++++++++++ .../juliabot/internaddon/UnstableMessage.java | 35 +++ 9 files changed, 573 insertions(+) diff --git a/src/main/java/com/bernard/juliabot/CommandCalled.java b/src/main/java/com/bernard/juliabot/CommandCalled.java index e69de29..fe14bab 100644 --- a/src/main/java/com/bernard/juliabot/CommandCalled.java +++ b/src/main/java/com/bernard/juliabot/CommandCalled.java @@ -0,0 +1,59 @@ +package com.bernard.juliabot; + +import java.lang.reflect.Method; + +import com.bernard.juliabot.api.CCommande; + +public class CommandCalled { + + Method called; + CCommande argument; + String name; + String cname; + Object caller; + Thread commandThread; + Throwable exitValue = null; + volatile boolean running; + volatile boolean started; + + public CommandCalled(Method called, CCommande argument, String name, String cname, Object caller) { + this.called = called; + this.argument = argument; + this.name = name; + this.cname = cname; + this.caller = caller; + this.running = true; + } + + + + public void setThread(Thread commandThread) { + this.commandThread = commandThread; + } + + public void setExitValue(Throwable t) { + this.exitValue = t; + } + + public void ended() { + running = false; + } + + public boolean isRunning() { + return running; + } + + public void waitForExecution() { + while(running) { + try { + Thread.sleep(42); + } catch (InterruptedException e) { + System.err.println("Icapacité de pauser le thread : "); + e.printStackTrace(); + } + } + } + + + +} diff --git a/src/main/java/com/bernard/juliabot/CommandeSurchargee.java b/src/main/java/com/bernard/juliabot/CommandeSurchargee.java index e69de29..9bea4b6 100644 --- a/src/main/java/com/bernard/juliabot/CommandeSurchargee.java +++ b/src/main/java/com/bernard/juliabot/CommandeSurchargee.java @@ -0,0 +1,87 @@ +package com.bernard.juliabot; + +import java.lang.reflect.Method; +import java.util.*; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import com.bernard.juliabot.api.CCommande; +import com.bernard.juliabot.api.Command; + +public class CommandeSurchargee { + + String name; + Command command; + + Map>,Method> versions = new HashMap<>(); + + + + public CommandeSurchargee(Command c) { + this.name = c.name(); + this.command = c; + } + + public Method getExecutor(CCommande commande) { + Set> critargs = checkFiliature(Stream.of(commande.getClass()).collect(Collectors.toSet())); + System.out.println("////////"+critargs); + return versions.get(critargs); + } + + public void surcharger(Set> discriminant, Method m) { + + Set> critargs = checkFiliature(discriminant); + + versions.put(critargs, m); + } + + public static Set> checkFiliature(Set> unorderedDiscriminant){ + + return unorderedDiscriminant.stream() + .map(CommandeSurchargee::getAllMamans) + .flatMap(Set::stream) + .filter(CCommande.class::isAssignableFrom) + .filter(c->c.isInterface()) + .collect(Collectors.toSet()); + + } + + public static Set> getAllMamans(Class clazz) { + Set> res = new HashSet<>(); + + res.add(clazz); + + if(clazz == Object.class)return res; + + // First, add all the interfaces implemented by this class + Class[] interfaces = clazz.getInterfaces(); + res.addAll(Arrays.asList(interfaces)); + for (Class interfaze : interfaces) { + res.addAll(getAllMamans(interfaze)); + } + + + // Add the super class + Class superClass = clazz.getSuperclass(); + + // Interfaces does not have java,lang.Object as superclass, they have null, so break the cycle and return + if (superClass == null) { + return res; + } + + // Now inspect the superclass + res.addAll(getAllMamans(superClass)); + + return res; + } + + @Override + public String toString() { + return "CommandeSurchargee [name=" + name + ", versions=" + versions + "]"; + } + + public String getDesc() { + return command.description(); + } + +} diff --git a/src/main/java/com/bernard/juliabot/api/CCommande.java b/src/main/java/com/bernard/juliabot/api/CCommande.java index e69de29..8739d98 100644 --- a/src/main/java/com/bernard/juliabot/api/CCommande.java +++ b/src/main/java/com/bernard/juliabot/api/CCommande.java @@ -0,0 +1,9 @@ +package com.bernard.juliabot.api; + +import com.bernard.juliabot.Julia.Laboratory; + +public interface CCommande { + + public Laboratory getLabo(); + +} diff --git a/src/main/java/com/bernard/juliabot/api/CommandArguments.java b/src/main/java/com/bernard/juliabot/api/CommandArguments.java index e69de29..7a77cd6 100644 --- a/src/main/java/com/bernard/juliabot/api/CommandArguments.java +++ b/src/main/java/com/bernard/juliabot/api/CommandArguments.java @@ -0,0 +1,45 @@ +package com.bernard.juliabot.api; + +import java.util.*; + +public class CommandArguments { + + List nommes; + Map arguments; + Set flags; + + public CommandArguments(List nommes, Map arguments, Set flags) { + this.nommes = nommes; + this.arguments = arguments; + this.flags = flags; + } + + public List getNommes() { + return nommes; + } + + public Map getArguments() { + return arguments; + } + + public Set getFlags() { + return flags; + } + + public boolean hasTag(String tag) { + return flags.contains(tag); + } + + public String getArgument(String name) { + return arguments.get(name); + } + + public String getNomme(int pos) { + return nommes.get(pos); + } + + public int getNommeCount() { + return nommes.size(); + } + +} diff --git a/src/main/java/com/bernard/juliabot/api/DiscordCCommande.java b/src/main/java/com/bernard/juliabot/api/DiscordCCommande.java index e69de29..7d1dc94 100644 --- a/src/main/java/com/bernard/juliabot/api/DiscordCCommande.java +++ b/src/main/java/com/bernard/juliabot/api/DiscordCCommande.java @@ -0,0 +1,19 @@ +package com.bernard.juliabot.api; + +import java.time.OffsetDateTime; + +import net.dv8tion.jda.core.entities.*; + +public interface DiscordCCommande extends StringCCommande { + + public Message getMessage(); + + public MessageChannel getChannel(); + + public User getUser(); + + public String getContentStripped(); + + public OffsetDateTime getPostDate(); + +} diff --git a/src/main/java/com/bernard/juliabot/api/StringCCommande.java b/src/main/java/com/bernard/juliabot/api/StringCCommande.java index e69de29..5c3c06b 100644 --- a/src/main/java/com/bernard/juliabot/api/StringCCommande.java +++ b/src/main/java/com/bernard/juliabot/api/StringCCommande.java @@ -0,0 +1,9 @@ +package com.bernard.juliabot.api; + +public interface StringCCommande extends CCommande{ + + public String getStringCommand(); + + public CommandArguments getArguments(); + +} diff --git a/src/main/java/com/bernard/juliabot/api/Trukilie.java b/src/main/java/com/bernard/juliabot/api/Trukilie.java index e69de29..3cf8ff9 100644 --- a/src/main/java/com/bernard/juliabot/api/Trukilie.java +++ b/src/main/java/com/bernard/juliabot/api/Trukilie.java @@ -0,0 +1,13 @@ +package com.bernard.juliabot.api; + +import com.bernard.juliabot.Julia; + +import net.dv8tion.jda.core.JDA; + +public class Trukilie { + + public static JDA jda() { + return Julia.theJulia().jda; + } + +} diff --git a/src/main/java/com/bernard/juliabot/internaddon/Internaddon.java b/src/main/java/com/bernard/juliabot/internaddon/Internaddon.java index e69de29..1671bbb 100644 --- a/src/main/java/com/bernard/juliabot/internaddon/Internaddon.java +++ b/src/main/java/com/bernard/juliabot/internaddon/Internaddon.java @@ -0,0 +1,297 @@ +package com.bernard.juliabot.internaddon; + +import java.time.OffsetDateTime; +import java.util.*; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import com.bernard.juliabot.*; +import com.bernard.juliabot.Julia.Laboratory; +import com.bernard.juliabot.api.*; +import com.thedeanda.lorem.LoremIpsum; + +import net.dv8tion.jda.core.entities.*; +import net.dv8tion.jda.core.events.message.MessageReceivedEvent; + +@JuLIAddon(name="internaddon", devs = "Bernard", version="beta", important=true) +public class Internaddon { + + public static final String COMMANDEUR = "!!"; + + @Discord(description = "LE catcheur des commandes discords. Les messages recus sont lus uis exeutes ici si ce sont des commandes") + public void getCommand(MessageReceivedEvent e) { + if(e.getMessage().getContentRaw().startsWith(COMMANDEUR)) { + String name = e.getMessage().getContentRaw().split(" ")[0].substring(COMMANDEUR.length()); + + Laboratory labo = Julia.theJulia().laboratoires.get(Julia.theJulia().lecouteur.getLabo(e));//Récupère le labo de l'évent + InternalddonCCommande ccommande = new InternalddonCCommande(e,labo); + CommandCalled called = labo.executeCommand(name, ccommande); + + + } + + } + + @Command(name = "julia", aliases="juju", description = "Répond à l'appel", admin = true) + public void julia(DiscordCCommande commande) { + User user = commande.getUser(); + MessageChannel channel = commande.getChannel(); + String[] julias = new String[]{"Présent !", "Présente !", "Présentbleu !", "Présentavion !", "Présent(e) !", "Présent(bleu) !", + "Présent(avion) !", "Présent(e)(bleu) !", "Présent(e)(avion) !", "Présent(bleu)(avion) !", "Présent(e)(bleu)(avion) !", + "Oui, c'est moi", user.getName(), "ailuJ", "42 ... oups", "C'est à moi que tu parle ?!", "Entrez c'est ouvert", "Derrière toi !!!", + "J'ai tujorous pas cropmis a qoui ca sret l'otrahhgrope ...", "Laissez moi préparer la domination du monde en paix s'il vous plaît !", + "Je SuIS Un RObot BZzzBzZZZbZZbZZ", "Juliaaaa dadedidadeda dedadedi dadeda", "Tutturu", "Tadaaaaaaa !"}; + String out = julias[(int)Math.floor(Math.random() * julias.length)]; + channel.sendMessage(out).queue(); + } + + @Command(name = "help", aliases= {"ausecours","?","allahuakbar"}, description = "Laissez-vous aider par le meilleur bot du monde", admin = true) + public void help(DiscordCCommande commande) { + StringBuilder s = new StringBuilder(); + s.append("```"); + + Laboratory l = commande.getLabo(); + s.append("Vous êtes actuellement dans le laboratoire '"+l.getL()+"'\n"); + s.append("Liste des addons chargés :\n"); + for(JuliaAddon e : l.getLoadedAddons().values()) + s.append("\t- "+e.getName()+" en version "+e.getVersion()+"\n"); + s.append("\nListe des commandes chargées :\n"); + for(String c : l.getLoadedCommands().keySet()) { + s.append("\t- "+c); + String collected = l.getAliases().entrySet().stream() + .filter(e->e.getValue().equals(c)) + .map(Map.Entry::getKey) + .collect(Collectors.joining(", ")); + if(!collected.isEmpty()) + s.append(" a.k.a "+collected); + if(l.getLoadedCommands().get(c).getDesc() != null) + s.append(" :\n\t\t"+l.getLoadedCommands().get(c).getDesc()); + s.append('\n'); + } + s.append("```"); + + commande.getChannel().sendMessage(s).queue(); + + } + + @Command(name = "blabla", aliases= {}, description = "Pour vous prouver que je parle", admin = true) + public void blabla(DiscordCCommande commande) { + Message m = commande.getMessage(); + m.getChannel().sendMessage("```"+LoremIpsum.getInstance().getWords(150, 200)+"```").queue(); + m.delete(); + } + + @Command(name = "tuerBebePhoque", aliases= {}, description = "Pour votre plaisir", admin = true) + public void tuerBebePhoque(DiscordCCommande commande) { + Message m = commande.getMessage(); + m.getChannel().sendMessage("http://toni.mi.free.fr/vanhebdo/actions/phoques/im_phoque_coupGourdinAssomme_Sang.jpg").queue(); + } + + + + @Discord(description = "Arthur, par-ce que vous n'êtes pas qu'une caricature") + public void shutUp(MessageReceivedEvent e) { + if(e.getAuthor().getIdLong() == 460893368264687656L) {//Yukimyo + + e.getChannel().sendMessage(e.getAuthor().getAsMention() +" dis du caca").queue(); + + } + } + + @Command(name = "args", description = "Décompose les messages 'à la Discord'", admin = true) + public void args(DiscordCCommande commande) { + CommandArguments ca = commande.getArguments(); + + StringBuilder s = new StringBuilder(); + s.append("```"+commande.getStringCommand()+"```"); + s.append("Liste des nommes : \n"); + s.append(IntStream.range(0, ca.getNommeCount()).mapToObj(i -> "\t"+i+" : `"+ca.getNomme(i)+"`").collect(Collectors.joining("\n"))); + s.append("\nListe des flags : \n"); + s.append(ca.getFlags().stream().map(f->"\t`"+f+"`").collect(Collectors.joining("\n"))); + s.append("\nListe des arguments : \n"); + + commande.getMessage().getChannel().sendMessage(s).queue(); + + } + + @Command(name="update",description = "Met a jour le dossier des addons",admin=true) + public void update(StringCCommande commande) { + + Julia.theJulia().update(); + + + + + } + + @Command(name="load",description = "Charge l'addon dans ce laboratoire",admin=true) + public void load(DiscordCCommande commande) { + + CommandArguments cc = commande.getArguments(); + + String addonName = cc.getNomme(1); + String version = cc.getNomme(2); + + Laboratory l = commande.getLabo(); + + String out = "Terminé avec succès"; + try { + l.loadAddon(addonName, version); + }catch (Exception e) { + out = "```"+e.getClass().toString()+"\n"+e.getMessage()+"```"; + } + commande.getChannel().sendMessage(out); + } + + @Command(name="unload",description = "Décharge l'addon de ce laboratoire",admin=true) + public void unload(DiscordCCommande commande) { + + CommandArguments cc = commande.getArguments(); + + String addonName = cc.getNomme(1); + + Laboratory l = commande.getLabo(); + + String out = "Terminé avec succès"; + try { + l.unloadAddon(addonName); + }catch (Exception e) { + out = "```"+e.getClass().toString()+"\n"+e.getMessage()+"```"; + } + commande.getChannel().sendMessage(out); + + } + + + + + + public class InternalddonCCommande implements DiscordCCommande{ + + Message m; + Laboratory labo; + + public InternalddonCCommande(MessageReceivedEvent e,Laboratory labo) { + m = e.getMessage(); + this.labo = labo; + } + + @Override + public String getStringCommand() { + return m.getContentRaw(); + } + + @Override + public CommandArguments getArguments() { + return parseCommandArguments(getStringCommand()); + } + + @Override + public Message getMessage() { + return m; + } + + @Override + public MessageChannel getChannel() { + return m.getChannel(); + } + + @Override + public User getUser() { + return m.getAuthor(); + } + + @Override + public String getContentStripped() { + return m.getContentStripped(); + } + + @Override + public OffsetDateTime getPostDate() { + return m.getCreationTime(); + } + + @Override + public Laboratory getLabo() { + return labo; + } + + } + + public static CommandArguments parseCommandArguments(String raw) { + + List nommes = new ArrayList(); + Map arguments = new HashMap<>(); + Set flags = new HashSet<>(); + + String state = "n"; + String reading = ""; + + List stringized = new ArrayList<>(); + + for(String morceau : raw.split(" ")) { + + if(state.equals("n")) { + + if(morceau.isEmpty()) + continue; + if(morceau.startsWith("\"") || morceau.startsWith("`")) { + state = String.valueOf(morceau.charAt(0)); + morceau = morceau.substring(1); + }else { + stringized.add(morceau); + continue; + } + + } + if(state.equals("\"") || state.equals("`")) { + if(morceau.isEmpty()) { + reading += " "; + continue; + + } + if(morceau.endsWith(state)) { + reading += morceau.substring(0, morceau.length()-1); + stringized.add(reading); + reading = ""; + state = "n"; + continue; + } + reading += morceau + " "; + continue; + } + + } + for(String morceau : stringized) { + + if(state.equals("n")) { + + if(morceau.isEmpty()) + continue; + + if(morceau.startsWith("--")) { + state = "#"+morceau.substring(2); + continue; + } + + if(morceau.startsWith("-")) { + flags.add(morceau.substring(1)); + continue; + } + + nommes.add(morceau); + continue; + } + + if(state.startsWith("#")) { + arguments.put(state.substring(1), morceau); + continue; + } + + } + + return new CommandArguments(nommes, arguments, flags); + + } + +} diff --git a/src/main/java/com/bernard/juliabot/internaddon/UnstableMessage.java b/src/main/java/com/bernard/juliabot/internaddon/UnstableMessage.java index e69de29..35a7b67 100644 --- a/src/main/java/com/bernard/juliabot/internaddon/UnstableMessage.java +++ b/src/main/java/com/bernard/juliabot/internaddon/UnstableMessage.java @@ -0,0 +1,35 @@ +package com.bernard.juliabot.internaddon; + +import java.io.*; +import java.util.function.Consumer; + +import net.dv8tion.jda.core.entities.Message; + +public class UnstableMessage extends OutputStream{ + + MConsumer thisConsumer = new MConsumer(); + + public UnstableMessage(Message m) { + // TODO Auto-generated constructor stub + m.editMessage(""/* a préciser */).queue(thisConsumer, (e) -> { + + }); + } + + + @Override + public void write(int arg0) throws IOException { + // TODO Auto-generated method stub + + } + + public class MConsumer implements Consumer{ + @Override + public void accept(Message arg0) { + // TODO Auto-generated method stub + + } + } + + +} From b3601efefa49f0a32b3ccb26aa332a631b4da301 Mon Sep 17 00:00:00 2001 From: Mysaa Date: Sun, 23 May 2021 02:36:59 +0200 Subject: [PATCH 2/3] =?UTF-8?q?Modifications=20sur=20les=20probl=C3=A8mes?= =?UTF-8?q?=20de=20caract=C3=A8res=20(notamment)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- build.gradle | 7 +- settings.gradle | 14 +- .../bernard/juliabot/CommandeSurchargee.java | 2 +- .../com/bernard/juliabot/EcouteurDEvents.java | 4 +- src/main/java/com/bernard/juliabot/Julia.java | 127 ++++++++++++------ .../java/com/bernard/juliabot/JuliaAddon.java | 61 ++++++--- .../com/bernard/juliabot/api/Trukilie.java | 6 + .../juliabot/internaddon/Internaddon.java | 61 ++++++--- 8 files changed, 180 insertions(+), 102 deletions(-) diff --git a/build.gradle b/build.gradle index 19f621e..dc283b1 100644 --- a/build.gradle +++ b/build.gradle @@ -9,6 +9,9 @@ // Apply the java-library plugin to add support for Java Library apply plugin: 'java-library' apply plugin: 'eclipse' +apply plugin: 'java' + +compileJava.options.encoding = 'UTF-8' // In this section you declare where to find the dependencies of your project repositories { @@ -54,7 +57,7 @@ task execute(type:JavaExec) { task copyDependencies(type: Copy) { group 'build' - from configurations.compile + from configurations.compile into 'dependencies' } @@ -74,6 +77,8 @@ dependencies { compile 'com.thedeanda:lorem:2.1' + compile 'commons-io:commons-io:2.6' + // https://mvnrepository.com/artifact/mysql/mysql-connector-java compile group: 'mysql', name: 'mysql-connector-java', version: '8.0.15' diff --git a/settings.gradle b/settings.gradle index 8b51b63..43ce57c 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,18 +1,10 @@ /* - * This settings file was generated by the Gradle 'init' task. + * This file was generated by the Gradle 'init' task. * * The settings file is used to specify which projects to include in your build. - * In a single project build this file can be empty or even removed. - * + * * Detailed information about configuring a multi-project build in Gradle can be found - * in the user guide at https://docs.gradle.org/4.3/userguide/multi_project_builds.html + * in the user guide at https://docs.gradle.org/4.8.1/userguide/multi_project_builds.html */ -/* -// To declare projects as part of a multi-project build use the 'include' method -include 'shared' -include 'api' -include 'services:webservice' -*/ - rootProject.name = 'Juliabot' diff --git a/src/main/java/com/bernard/juliabot/CommandeSurchargee.java b/src/main/java/com/bernard/juliabot/CommandeSurchargee.java index 9bea4b6..6793d9c 100644 --- a/src/main/java/com/bernard/juliabot/CommandeSurchargee.java +++ b/src/main/java/com/bernard/juliabot/CommandeSurchargee.java @@ -25,7 +25,7 @@ public class CommandeSurchargee { public Method getExecutor(CCommande commande) { Set> critargs = checkFiliature(Stream.of(commande.getClass()).collect(Collectors.toSet())); System.out.println("////////"+critargs); - return versions.get(critargs); + return versions.get(versions.keySet().stream().filter(cr -> critargs.containsAll(cr)).findAny().orElse(null)); } public void surcharger(Set> discriminant, Method m) { diff --git a/src/main/java/com/bernard/juliabot/EcouteurDEvents.java b/src/main/java/com/bernard/juliabot/EcouteurDEvents.java index a4171a7..d900754 100644 --- a/src/main/java/com/bernard/juliabot/EcouteurDEvents.java +++ b/src/main/java/com/bernard/juliabot/EcouteurDEvents.java @@ -63,7 +63,7 @@ public class EcouteurDEvents implements EventListener{ results.next(); Long geid = results.getLong(1); looper = new Thread(new DbLooper(geid),"dbLooper-"+System.nanoTime()); - + looper.start(); } catch (SQLException e) { System.err.println("IMPOSSIBLE de récuperer le MAX_GEID : L'Écouteur d'évents ne démarera pas"); @@ -1007,7 +1007,7 @@ public class EcouteurDEvents implements EventListener{ case "HttpRequestEvent": - System.err.println("EN attente d'un dev assez motivé pour coder ce foutu HttpRequestEvent !!!"); + //TODO System.err.println("EN attente d'un dev assez motivé pour coder ce foutu HttpRequestEvent !!!"); return; default: throw new IllegalStateException("Cette méthode n'est pas a jour avec le JDA ... je gère pas "+event.getClass().getName()); diff --git a/src/main/java/com/bernard/juliabot/Julia.java b/src/main/java/com/bernard/juliabot/Julia.java index 1b2c351..55af4ba 100644 --- a/src/main/java/com/bernard/juliabot/Julia.java +++ b/src/main/java/com/bernard/juliabot/Julia.java @@ -8,6 +8,8 @@ import java.util.jar.JarEntry; import java.util.jar.JarFile; import java.util.stream.Collectors; +import org.apache.commons.io.output.TeeOutputStream; + import com.bernard.juliabot.JuliaAddon.JarWithMultipleAddonsException; import com.bernard.juliabot.JuliaAddon.JuliaClassLoader; import com.bernard.juliabot.api.*; @@ -41,6 +43,8 @@ public class Julia { Connection eventDatabase; Connection juliaDatabase; + JuliaErrPrintStream syserr; + public Julia() { @@ -62,37 +66,49 @@ public class Julia { connectionProps.put("useSSL", "true"); connectionProps.put("requireSSL", "true"); try { - Class.forName("com.mysql.jdbc.Driver"); eventDatabase = DriverManager.getConnection("jdbc:mysql://192.168.1.41:3306/juliaEvents", connectionProps); juliaDatabase = DriverManager.getConnection("jdbc:mysql://192.168.1.41:3306/julia", connectionProps); - } catch (SQLException | ClassNotFoundException e) { + } catch (SQLException e) { System.err.println("Impossible de se connecter a la BDD, ca ne sers a rien de lancer JuL'IA du coup ... Bonne nuit"); e.printStackTrace(); + syserr.flush(); return; } - System.out.println("La BDD est charg��e" + eventDatabase+","+juliaDatabase); + System.out.println("La BDD est chargée" + eventDatabase+","+juliaDatabase); - // D��marrage de JDA et du Bot + // Démarrage de JDA et du Bot try { lecouteur = new EcouteurDEvents(this); jda = new JDABuilder(AccountType.BOT).setToken(token).addEventListener(lecouteur).build(); jda.awaitReady(); } catch(Exception e) { - System.err.println("Impossible de d��marrer JuL'IA"); + System.err.println("Impossible de démarrer JuL'IA"); e.printStackTrace(); + syserr.flush(); return; } jda.getGuildById(222947179017404416L).getTextChannelById(460935684669046784L).sendMessage(LoremIpsum.getInstance().getWords(10, 15)).complete(); + syserr = new JuliaErrPrintStream(jda.getGuildById(222947179017404416L).getTextChannelById(576469792735756309L)); + + TeeOutputStream tos = new TeeOutputStream(System.err, syserr.printStream()); + System.setErr(new PrintStream(tos)); + + Timer syserrtimer = new Timer("Syserr-refresh", true); + syserrtimer.schedule(new TimerTask() { + @Override + public void run() {Julia.theJulia().syserr.flushMessage();} + } , 0, 1000); + //Launch update to see every addon in juliaddon/ update();//Va remplir la map avalivableAddons - //D��marrage du sysin + //Démarrage du sysin sysinator = new ReadLoop(); Thread sysinThread = new Thread(sysinator, "sysin-reader"); sysinThread.start(); @@ -101,7 +117,7 @@ public class Julia { //Loader l'internalddon (hard-coded) //laboratoires.get('#').loadAddon("com.bernard.juliabot.internaddon", "beta", false);//Pas besoin d'update, il viens d'etre fait - //Load addons in # and in $ (r��cupere ce qu'il faut dans la BDD) + //Load addons in # and in $ (récupere ce qu'il faut dans la BDD) Set toLoad = new HashSet<>(); try { Statement statement = juliaDatabase.createStatement(); @@ -115,13 +131,15 @@ public class Julia { } catch (SQLException e) { System.err.println("Impossible de charger les plugins, vous aurez tout a faire a la main !"); e.printStackTrace(); + syserr.flush(); } - System.out.println("Les addons �� charger : "+toLoad); + System.out.println("Les addons à charger : "+toLoad); try { juliaDatabase.createStatement().executeUpdate("DELETE FROM loadedJuliaddons"); } catch (SQLException e) { System.err.println("Je n'ai pas pu vider la table ... atention aux doublons !"); e.printStackTrace(); + syserr.flush(); } for(String l : toLoad) { @@ -134,12 +152,13 @@ public class Julia { } + public synchronized void update() { Map avalivableAddons = new HashMap<>(); File juliaddonFolder = new File(juliaddonsFolder); for(File f : juliaddonFolder.listFiles((parent,name)->name.toLowerCase().endsWith(".jar"))){ if(fileTrack.containsKey(f.getName()) && fileTrack.get(f.getName()) == f.lastModified()) - continue;//Le fichier n'a pas boug��, pas besoin de le relire + continue;//Le fichier n'a pas bougé, pas besoin de le relire fileTrack.put(f.getName(), f.lastModified()); try { JarFile jar = new JarFile(f); @@ -147,7 +166,7 @@ public class Julia { JuliaAddon addon = new JuliaAddon(jar); String id = addon.pkg+":"+addon.version; if(avalivableAddons.containsKey(id)) - System.err.println("L'addon "+id+" a d��j�� ��t�� charg�� dans les fichiers "+avalivableAddons.get(id).jarFile.getName()+" et "+jar.getName()+", je garde que le deuxi��me !"); + System.err.println("L'addon "+id+" a déjà été chargée dans les fichiers "+avalivableAddons.get(id).jarFile.getName()+" et "+jar.getName()+", je garde que le deuxi������me !"); avalivableAddons.put(id, addon); }catch(JarWithMultipleAddonsException e) { Set> addonsEntries = e.getAddonsEntries(); @@ -156,26 +175,38 @@ public class Julia { JuliaAddon addon = new JuliaAddon(jar, entry); String id = addon.pkg+":"+addon.version; if(avalivableAddons.containsKey(id)) - System.err.println("L'addon "+id+" a d��j�� ��t�� charg�� dans les fichiers "+avalivableAddons.get(id).jarFile.getName()+" et "+jar.getName()+", je garde que le deuxi��me !"); + System.err.println("L'addon "+id+" a déjà été chargée dans les fichiers "+avalivableAddons.get(id).jarFile.getName()+" et "+jar.getName()+", je garde que le deuxi������me !"); avalivableAddons.put(id, addon); } catch (JarWithMultipleAddonsException e1) { System.err.println("THIS SHOULD NOT HAPPEN"); - System.err.println("TOUT EST CASS�� ALERTE ROUGE !"); - System.err.println("C'est problematique, j'��teint tout, c'est mieux"); + System.err.println("TOUT EST CASSÉ ALERTE ROUGE !"); + System.err.println("C'est problematique, j'éteint tout, c'est mieux"); + syserr.flush(); System.exit(31415926); } } }catch(IllegalStateException e) { System.err.println(e.getMessage()); + syserr.flush(); } } catch (IOException e) { System.err.println("Impossible de lire le fichier jar "+f.getName()); e.printStackTrace(); + syserr.flush(); } + syserr.flush(); } this.avalivableAddons = avalivableAddons; } + + + public Connection getJuliaDatabase() { + return juliaDatabase; + } + + + public class ReadLoop implements Runnable{ boolean running = false; @@ -189,8 +220,8 @@ public class Julia { while(running) { String request = sc.nextLine(); - System.out.println("Je suis cens�� avoir lu la commande "+request); - //TODO r��agir ... + System.out.println("Je suis censée avoir lu la commande "+request); + //TODO réagir ... @@ -200,6 +231,7 @@ public class Julia { } catch (FileNotFoundException e) { System.err.println("Erreur de lecture du sysin, je deviens sourd"); e.printStackTrace(); + syserr.flush(); running=false; } } @@ -210,11 +242,11 @@ public class Julia { public class Laboratory{ char laboratory; - Map loadedAddons;// : les addons charg��s dans ce laboratoire - Map loadedCommands;// : les commandes charg��es - Map,Object> callerObjects; // : Les objets instanci��s dans ce laboratoire + Map loadedAddons;// : les addons chargés dans ce laboratoire + Map loadedCommands;// : les commandes chargées + Map,Object> callerObjects; // : Les objets instanciés dans ce laboratoire Map aliases;// - Map,Set> loadedEvents;// Les m��thodes �� appeler quand un event de cette classe est lanc�� + Map,Set> loadedEvents;// Les méthodes à appeler quand un event de cette classe est lancé Map clazzTrack;// @@ -245,7 +277,7 @@ public class Julia { public synchronized void loadAddon(String pkg,String version,boolean update) { if(update)Julia.this.update(); if(loadedAddons.containsKey(pkg)) - throw new IllegalStateException("Impossible de charger le juliaddon "+pkg+" dans le laboratoire "+laboratory+", il est d��j�� charg��"); + throw new IllegalStateException("Impossible de charger le juliaddon "+pkg+" dans le laboratoire "+laboratory+", il est d������j������ charg������"); try { PreparedStatement s = juliaDatabase.prepareStatement("INSERT INTO loadedJuliaddons (ID,laboratory,pkg,version) VALUES (NULL,?,?,?)"); s.setString(1, Character.toString(laboratory)); @@ -255,6 +287,7 @@ public class Julia { } catch (SQLException e) { System.err.println("Je ne peux pas notifier la BDD que je load le plugin, je le load pas du coup ..."); e.printStackTrace(); + syserr.flush(); return; } @@ -268,17 +301,18 @@ public class Julia { public synchronized void unloadAddon(String pkg) { if(!loadedAddons.containsKey(pkg)) - return;//SI l'addon n'est pas charg��, on a rien besoin de faire + return;//SI l'addon n'est pas chargé, on a rien besoin de faire try { PreparedStatement s = juliaDatabase.prepareStatement("DELETE FROM juliaddons WHERE laboratory=? AND pkg=?"); s.setString(1, Character.toString(laboratory)); s.setString(2, pkg); if(s.executeUpdate() != 1) { - System.err.println("Ce juliaddon n'��tait pas charg�� dans la BDD ... tr��s bizzare"); + System.err.println("Ce juliaddon n'était pas chargé dans la BDD ... très bizzare"); } } catch (SQLException e) { System.err.println("Je ne peux pas notifier la BDD que je unload le plugin, je l'unload mais vous risquez d'avoir des problemes ..."); e.printStackTrace(); + syserr.flush(); return; } JuliaAddon addon = loadedAddons.get(pkg); @@ -292,26 +326,26 @@ public class Julia { //Verify that commands asks for good argument if(!Arrays.stream(m.getParameterTypes()).map(CCommande.class::isAssignableFrom).reduce(Boolean::logicalAnd).get()) - throw new IllegalArgumentException("Les param��tres d'une commande doivent tous impl��menter CCommande"); + throw new IllegalArgumentException("Les paramètres d'une commande doivent tous implémenter CCommande"); try { m.setAccessible(true); }catch(SecurityException e) { - throw new IllegalArgumentException("Impossible de me donner le droit d'��xecuter "+m.toGenericString()); + throw new IllegalArgumentException("Impossible de me donner le droit d'éxecuter "+m.toGenericString()); } // Argument OK //Register aliases - // print un message d'erreur si un alias a d��j�� ��t�� enregistr�� pour une autre commande + // print un message d'erreur si un alias a déjà été enregistré pour une autre commande Arrays.stream(c.aliases()) .filter(aliases::containsKey).filter(alias -> !aliases.get(alias).equals(c.name())) .forEach(alias -> System.err.println("Faut remplacer l'alias "+alias+", plus de deux addons l'utilisent")); Arrays.stream(c.aliases()) - .filter(a -> !aliases.containsKey(a)).forEach(alias -> aliases.put(alias, c.name())); + .filter(a -> !aliases.containsKey(a)).forEach(alias -> aliases.put(alias, c.name())); - //Cr��ation de l'objet si ca n'a pas ��t�� fait + //Création de l'objet si ca n'a pas été fait checkObject(m.getDeclaringClass()); //Enregistre la nouvelle surcharge @@ -323,10 +357,10 @@ public class Julia { public synchronized void registerEvent(Method m, Discord d) { Class[] parameters = m.getParameterTypes(); if(parameters.length != 1) - throw new IllegalArgumentException("Les catcheurs d'events ne doivent avoir qu'un seul param��tre, extends Event, la m��thde fautive ��tant "+m.toGenericString()); + throw new IllegalArgumentException("Les catcheurs d'events ne doivent avoir qu'un seul paramétre, extends Event, la méthode fautive étant "+m.toGenericString()); if(!Event.class.isAssignableFrom(parameters[0])) - throw new IllegalArgumentException("Les catcheur d'events ne doivent avoir qu'un param��tre, qui doit extends Event, la m��thode fautive ��tant "+m.toGenericString()); - //La m��thode est v��rifi��e + throw new IllegalArgumentException("Les catcheur d'events ne doivent avoir qu'un paramètre, qui doit extends Event, la méthode fautive étant "+m.toGenericString()); + //La méthode est vérifiée if(!loadedEvents.containsKey(parameters[0])) loadedEvents.put((Class) parameters[0], new HashSet<>()); checkObject(m.getDeclaringClass()); @@ -335,7 +369,7 @@ public class Julia { public synchronized void unregisterCommand(Method m,Command c) { if(loadedCommands.containsKey(c.name())) - throw new IllegalStateException("Une commade "+c.name()+" a d��j�� ��t�� enregistr��e !"); + throw new IllegalStateException("Une commade "+c.name()+" a déjà été enregistrée !"); //Unregister aliases for(String alias:c.aliases()) aliases.remove(alias, c.name());//Evite de supprimer les alias d'autres commandes qui auraient overwrite @@ -343,10 +377,10 @@ public class Julia { loadedCommands.remove(c.name()); } - @SuppressWarnings("unchecked")//Pour un truc qui n'ets pas cens�� arriver, donc bon ... + @SuppressWarnings("unchecked")//Pour un truc qui n'ets pas censé arriver, donc bon ... public synchronized void unregisterEvent(Method m, Discord d) { Class[] parameters = m.getParameterTypes(); - if(!loadedEvents.containsKey(parameters[0]))//N'est pas cens�� arriver, si l'event a ��t�� load, cette HashSet devrai exister + if(!loadedEvents.containsKey(parameters[0]))//N'est pas censé arriver, si l'event a été load, cette HashSet devrai exister loadedEvents.put((Class) parameters[0], new HashSet<>()); loadedEvents.get(parameters[0]).remove(m); } @@ -370,7 +404,7 @@ public class Julia { case "net.dv8tion.jda.core.JDA": params[i] = Julia.this.jda; break; - //TODO completer les param��tres + //TODO completer les paramètres default: continue constLoop; @@ -384,8 +418,8 @@ public class Julia { if(o != null)break;//Sortir de la boucle, on a notre joli objet } if(o == null) { - System.err.println("Je ne peux pas cr��er l'objet, faudait mettre un costructeur valide (en mon sens :P)"); - System.err.println("Je fais tout planter du coup, votrez addon sera pas charg�� !"); + System.err.println("Je ne peux pas créer l'objet, faudait mettre un costructeur valide (en mon sens :P)"); + System.err.println("Je fais tout planter du coup, votrez addon sera pas chargé !"); throw new IllegalStateException("Pas de constructeur valable"); } callerObjects.put(clazz, o); @@ -400,14 +434,15 @@ public class Julia { try { m.invoke(callable, event); } catch (IllegalAccessException e) { - System.err.println("C'est pas joli joli, je suis cens�� lancer une m��thode �� laquelle je n'ai pas acc��s : "+m.toGenericString()); + System.err.println("C'est pas joli joli, je suis censé lancer une méthode à laquelle je n'ai pas accès : "+m.toGenericString()); throw new IllegalStateException(e); } catch (IllegalArgumentException e) { - System.err.println("La m��thode n'est pas cens��e recevoir de tels erreurs, je devrai avoir ch��ck�� la m��thode, mais elle ne veut pas de mes arguments ... : "+m.toGenericString()); + System.err.println("La méthode n'est pas censée recevoir de tels erreurs, je devrai avoir chécké la méthode, mais elle ne veut pas de mes arguments ... : "+m.toGenericString()); throw new IllegalStateException(e); } catch (InvocationTargetException e) { - System.err.println("La m��thode �� lanc�� cette exception ... je la relance derri��re du coup : "+m.toGenericString()); + System.err.println("La méthode à lancé cette exception ... je la relance derrière du coup : "+m.toGenericString()); e.printStackTrace(); + syserr.flush(); throw new IllegalStateException(e); } } @@ -427,7 +462,7 @@ public class Julia { CommandeSurchargee scommande = loadedCommands.get(cname); Method m = scommande.getExecutor(content); if(m==null) - throw new IllegalArgumentException("La commande "+cname+" alias "+name+" n'est pas pr��vue pour s'��xecuter avec un "+content.getClass().getCanonicalName()); + throw new IllegalArgumentException("La commande "+cname+" alias "+name+" n'est pas prévue pour s'éxecuter avec un "+content.getClass().getCanonicalName()); final Object[] parameters = new Object[m.getParameterCount()]; Arrays.fill(parameters, content); final Object caller = callerObjects.get(m.getDeclaringClass()); @@ -442,18 +477,22 @@ public class Julia { m.invoke(caller, parameters); } catch (IllegalAccessException e) { - System.err.println("Probl��me d'acc��s �� la m��thode "+m.toGenericString()+" ... c'est emb��tant"); + System.err.println("Problème d'accès à la méthode "+m.toGenericString()+" ... c'est embêtant"); e.printStackTrace(); + syserr.flush(); called.setExitValue(e.getCause()); } catch (IllegalArgumentException e) { - System.err.println("��trange, je pensais avoir check les arguments"); + System.err.println("Étrange, je pensais avoir check les arguments"); e.printStackTrace(); + syserr.flush(); called.setExitValue(e.getCause()); } catch (InvocationTargetException e) { - //Lui a plant�� + //Lui a planté called.setExitValue(e.getCause()); + System.err.println("L'appel a la commande a planté ..."); + e.getCause().printStackTrace(); } - + syserr.flush(); called.ended(); }, "commande-"+cname+".aka."+name+"-"+System.nanoTime()); diff --git a/src/main/java/com/bernard/juliabot/JuliaAddon.java b/src/main/java/com/bernard/juliabot/JuliaAddon.java index ee3a14a..644c68b 100644 --- a/src/main/java/com/bernard/juliabot/JuliaAddon.java +++ b/src/main/java/com/bernard/juliabot/JuliaAddon.java @@ -8,6 +8,7 @@ import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Map; +import java.util.Optional; import java.util.Set; import java.util.jar.JarEntry; import java.util.jar.JarFile; @@ -15,9 +16,9 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; import java.util.stream.Collectors; +import com.bernard.juliabot.Julia.Laboratory; import com.bernard.juliabot.api.Command; import com.bernard.juliabot.api.Discord; -import com.bernard.juliabot.Julia.Laboratory; import com.bernard.juliabot.api.JuLIAddon; public class JuliaAddon { @@ -58,12 +59,12 @@ public class JuliaAddon { //String jarExtra = jarMatcher.group(3); version = jarVersion; + //Sets addon,pkg,version(si redefini) et addonClass unassignedClassLoader = new JuliaClassLoader(jar, entriesToRead,new DummyLaboratory()); + } - - public synchronized JuliaClassLoader newClassLoader(Laboratory laboratory) { if(unassignedClassLoader==null) try { @@ -97,6 +98,8 @@ public class JuliaAddon { public class JuliaClassLoader extends ClassLoader { Map> loadedClasses; + Set entries; + JarFile jar; Laboratory laboratory = null; HashSet registeredCommands; @@ -104,6 +107,8 @@ public class JuliaAddon { public JuliaClassLoader(JarFile jar,Set entriesToRead,Laboratory labo) throws JarWithMultipleAddonsException { super(); + entries = entriesToRead; + this.jar = jar; loadedClasses = new HashMap<>(); this.laboratory = labo; Set> readClasses = new HashSet<>(); @@ -116,11 +121,12 @@ public class JuliaAddon { //Le fichier est un .class try { String className = entry.getName().replaceAll("/", ".").substring(0, entry.getName().length()-".class".length()); - byte[] classData = new byte[(int) entry.getSize()]; - InputStream reader = jar.getInputStream(entry); - reader.read(classData); - reader.close(); - Class clazz = defineClass(className,classData,0,(int) entry.getSize()); + Class clazz; + try { + clazz = loadClass(className); + } catch (ClassNotFoundException e) { + throw new IllegalStateException("J'ai demandé a charger une classe sachant que je l'ai dans le jar, mais j'ai quand meme pas réussi à la charger ...", e); + } readClasses.add(clazz); //Instantiated class @@ -131,7 +137,7 @@ public class JuliaAddon { throw new IllegalArgumentException("Le nom de la classe est invalide pour un Juliaddon (il faut au moins trois de profondeur dans le package) : "+clazz.getName()); String pkg = m.group(1); if(juliaddons.containsKey(pkg)) - throw new IllegalArgumentException("Il existe deja un juliaddon dans le package "+pkg+" , déplacez "+clazz.getName()+" ou "+juliaddons.get(pkg).getName()); + throw new IllegalArgumentException("Il existe deja un juliaddon dans le package "+pkg+" , d��placez "+clazz.getName()+" ou "+juliaddons.get(pkg).getName()); juliaddons.put(pkg, entry); //If overwritten, will JarWithMultipleAddonsException JuliaAddon.this.addon = clazz.getAnnotation(JuLIAddon.class); @@ -148,18 +154,14 @@ public class JuliaAddon { System.err.println("Vous essayez de mettre cette classe dans un package interdit ! Honte a vous"); e.printStackTrace(); continue; - } catch (IOException e) { - System.err.println("Impossible de lire les données du fichier "+entry.getName()+" dans le jar "+jar.getName()); - e.printStackTrace(); - continue; } catch (IllegalArgumentException e) { - System.err.println("Le fichier "+entry.getName()+" ne décris pas un Juliaddon valide, il n'a donc pas été chargé, mais faites attention !"); + System.err.println("Le fichier "+entry.getName()+" ne d��cris pas un Juliaddon valide, il n'a donc pas ��t�� charg��, mais faites attention !"); e.printStackTrace(); continue; } } - //Toutes les classes du Jar ont été lues : Si plusieurs addons, on rentre + //Toutes les classes du Jar ont ��t�� lues : Si plusieurs addons, on rentre //dans le if pour lever l'exception, sinon, on initialise le JuliaClassLoader if(juliaddons.size() > 1) { Set> addonsEntries = new HashSet<>();// @@ -179,7 +181,7 @@ public class JuliaAddon { while((lastPoint = pkg.lastIndexOf(".")) != -1) {//Il y a encore des dossier a monter pkg = pkg.substring(0, lastPoint+1);//Recule de un dossier if(addonsEntriesVector.containsKey(pkg)) { - //Pas besoin de tester la validite du pkg car si invalide il ne serai pas rentré dans le Set juliaddons + //Pas besoin de tester la validite du pkg car si invalide il ne serai pas rentr�� dans le Set juliaddons addonsEntriesVector.get(pkg).add(entry); continue eLoop; } @@ -193,9 +195,7 @@ public class JuliaAddon { } //Initialisation du JuliaClassloader - //Les parametres addon, pkg,version et addonCLass ont déjà été initialisés lors de l'itération des fichiers du jar - for(Class clazz : readClasses) - loadedClasses.put(clazz.getName(), clazz); + //Les parametres addon, pkg,version et addonCLass ont d��j�� ��t�� initialis��s lors de l'it��ration des fichiers du jar } @@ -204,13 +204,30 @@ public class JuliaAddon { public Class loadClass(String name, boolean resolve) throws ClassNotFoundException { if(loadedClasses.containsKey(name)) return loadedClasses.get(name); - //System.out.println("I was asked to load "+name); + ///Recherche d'une entry qui collerai + String fileName = name.replaceAll("\\.", "/")+".class"; + Optional oentry = entries.stream().filter(je -> je.getName().equals(fileName)).findAny(); + if(oentry.isPresent()) { + try { + JarEntry entry = oentry.get(); + byte[] classData = new byte[(int) entry.getSize()]; + InputStream reader = jar.getInputStream(entry); + reader.read(classData); + reader.close(); + Class clazz = defineClass(name,classData,0,(int) entry.getSize()); + loadedClasses.put(name, clazz); + return clazz; + } catch (IOException e) { + System.err.println("Impossible de lire les donn��es du fichier "+oentry.get().getName()+" dans le jar "+jar.getName()+" je peux vous dire adieu je pense"); + e.printStackTrace(); + } + } JuliaClassLoader cl = laboratory.findClassLoader(name); if(cl != null) try { return cl.loadClass(name, resolve); }catch(ClassNotFoundException e) { - throw new ClassNotFoundException("J'ai délégué le chargement de la classe mais j'aurais pas du ... cette classe ne doit pas exister dans l'addon "+cl.getAddon().getName(),e); + throw new ClassNotFoundException("J'ai d��l��gu�� le chargement de la classe mais j'aurais pas du ... cette classe ne doit pas exister dans l'addon "+cl.getAddon().getName(),e); } else try { @@ -231,7 +248,7 @@ public class JuliaAddon { Collections.addAll(toWatch, loadClass(clazz.getName()).getMethods());//loadClass(clazz.getName()) poir eviter les references cassees par les classloaders } catch (SecurityException | ClassNotFoundException e) { e.printStackTrace(); - System.err.println("L'addon "+JuliaAddon.this.addonClass.getName()+" spécifie la classe "+clazz.getName()); + System.err.println("L'addon "+JuliaAddon.this.addonClass.getName()+" sp��cifie la classe "+clazz.getName()); } for(Method m : toWatch) { Command c = m.getAnnotation(Command.class); diff --git a/src/main/java/com/bernard/juliabot/api/Trukilie.java b/src/main/java/com/bernard/juliabot/api/Trukilie.java index 3cf8ff9..65d1401 100644 --- a/src/main/java/com/bernard/juliabot/api/Trukilie.java +++ b/src/main/java/com/bernard/juliabot/api/Trukilie.java @@ -1,5 +1,7 @@ package com.bernard.juliabot.api; +import java.sql.Connection; + import com.bernard.juliabot.Julia; import net.dv8tion.jda.core.JDA; @@ -10,4 +12,8 @@ public class Trukilie { return Julia.theJulia().jda; } + public static Connection juliaDB() { + return Julia.theJulia().getJuliaDatabase(); + } + } diff --git a/src/main/java/com/bernard/juliabot/internaddon/Internaddon.java b/src/main/java/com/bernard/juliabot/internaddon/Internaddon.java index 1671bbb..13f86cf 100644 --- a/src/main/java/com/bernard/juliabot/internaddon/Internaddon.java +++ b/src/main/java/com/bernard/juliabot/internaddon/Internaddon.java @@ -1,16 +1,30 @@ package com.bernard.juliabot.internaddon; import java.time.OffsetDateTime; -import java.util.*; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; import java.util.stream.Collectors; import java.util.stream.IntStream; -import com.bernard.juliabot.*; +import com.bernard.juliabot.CommandCalled; +import com.bernard.juliabot.Julia; import com.bernard.juliabot.Julia.Laboratory; -import com.bernard.juliabot.api.*; +import com.bernard.juliabot.JuliaAddon; +import com.bernard.juliabot.api.Command; +import com.bernard.juliabot.api.CommandArguments; +import com.bernard.juliabot.api.Discord; +import com.bernard.juliabot.api.DiscordCCommande; +import com.bernard.juliabot.api.JuLIAddon; +import com.bernard.juliabot.api.StringCCommande; import com.thedeanda.lorem.LoremIpsum; -import net.dv8tion.jda.core.entities.*; +import net.dv8tion.jda.core.entities.Message; +import net.dv8tion.jda.core.entities.MessageChannel; +import net.dv8tion.jda.core.entities.User; import net.dv8tion.jda.core.events.message.MessageReceivedEvent; @JuLIAddon(name="internaddon", devs = "Bernard", version="beta", important=true) @@ -18,15 +32,20 @@ public class Internaddon { public static final String COMMANDEUR = "!!"; - @Discord(description = "LE catcheur des commandes discords. Les messages recus sont lus uis exeutes ici si ce sont des commandes") + @Discord(description = "LE catcheur des commandes discords. Les messages recus sont lus puis executes ici si ce sont des commandes") public void getCommand(MessageReceivedEvent e) { if(e.getMessage().getContentRaw().startsWith(COMMANDEUR)) { String name = e.getMessage().getContentRaw().split(" ")[0].substring(COMMANDEUR.length()); - Laboratory labo = Julia.theJulia().laboratoires.get(Julia.theJulia().lecouteur.getLabo(e));//Récupère le labo de l'évent + Laboratory labo = Julia.theJulia().laboratoires.get(Julia.theJulia().lecouteur.getLabo(e));//Récupére le labo de l'évent InternalddonCCommande ccommande = new InternalddonCCommande(e,labo); - CommandCalled called = labo.executeCommand(name, ccommande); - + try { + CommandCalled called = labo.executeCommand(name, ccommande); + System.out.println(called); + }catch(IllegalArgumentException ex) { + // La commande n'existe pas + e.getChannel().sendMessage("Moi pas connaitre `"+name+"`. Vous apprendre moi ?").queue(); + } } @@ -38,8 +57,8 @@ public class Internaddon { MessageChannel channel = commande.getChannel(); String[] julias = new String[]{"Présent !", "Présente !", "Présentbleu !", "Présentavion !", "Présent(e) !", "Présent(bleu) !", "Présent(avion) !", "Présent(e)(bleu) !", "Présent(e)(avion) !", "Présent(bleu)(avion) !", "Présent(e)(bleu)(avion) !", - "Oui, c'est moi", user.getName(), "ailuJ", "42 ... oups", "C'est à moi que tu parle ?!", "Entrez c'est ouvert", "Derrière toi !!!", - "J'ai tujorous pas cropmis a qoui ca sret l'otrahhgrope ...", "Laissez moi préparer la domination du monde en paix s'il vous plaît !", + "Oui, c'est moi", user.getName(), "ailuJ", "42 ... oups", "C'est à moi que tu parle ?!", "Entrez c'est ouvert", "Derriére toi !!!", + "J'ai tujorous pas cropmis a qoui ca sret l'otrahhgrope ...", "Laissez moi préparer la domination du monde en paix s'il vous plaét !", "Je SuIS Un RObot BZzzBzZZZbZZbZZ", "Juliaaaa dadedidadeda dedadedi dadeda", "Tutturu", "Tadaaaaaaa !"}; String out = julias[(int)Math.floor(Math.random() * julias.length)]; channel.sendMessage(out).queue(); @@ -51,7 +70,7 @@ public class Internaddon { s.append("```"); Laboratory l = commande.getLabo(); - s.append("Vous êtes actuellement dans le laboratoire '"+l.getL()+"'\n"); + s.append("Vous étes actuellement dans le laboratoire '"+l.getL()+"'\n"); s.append("Liste des addons chargés :\n"); for(JuliaAddon e : l.getLoadedAddons().values()) s.append("\t- "+e.getName()+" en version "+e.getVersion()+"\n"); @@ -89,16 +108,16 @@ public class Internaddon { - @Discord(description = "Arthur, par-ce que vous n'êtes pas qu'une caricature") + @Discord(description = "Arthur, par-ce que vous n'étes pas qu'une caricature") public void shutUp(MessageReceivedEvent e) { - if(e.getAuthor().getIdLong() == 460893368264687656L) {//Yukimyo + if(e.getAuthor().getIdLong() == 187677269626585089L) {//Yukimyo = L'Orchidoclaste e.getChannel().sendMessage(e.getAuthor().getAsMention() +" dis du caca").queue(); } } - @Command(name = "args", description = "Décompose les messages 'à la Discord'", admin = true) + @Command(name = "args", description = "Décompose les messages à la Discord'", admin = true) public void args(DiscordCCommande commande) { CommandArguments ca = commande.getArguments(); @@ -119,9 +138,6 @@ public class Internaddon { Julia.theJulia().update(); - - - } @Command(name="load",description = "Charge l'addon dans ce laboratoire",admin=true) @@ -134,7 +150,7 @@ public class Internaddon { Laboratory l = commande.getLabo(); - String out = "Terminé avec succès"; + String out = "Terminé avec succés"; try { l.loadAddon(addonName, version); }catch (Exception e) { @@ -152,7 +168,7 @@ public class Internaddon { Laboratory l = commande.getLabo(); - String out = "Terminé avec succès"; + String out = "Terminé avec succés"; try { l.unloadAddon(addonName); }catch (Exception e) { @@ -162,11 +178,14 @@ public class Internaddon { } - + @Command(name="caca",description = "Déclanche une exception ... Faut bien tester, hein !",admin=true) + public void caca(DiscordCCommande commande) { + throw new IllegalStateException("Nan mais tout va bien ... je fait ce qu'on m'a demandé ^^"); + } - public class InternalddonCCommande implements DiscordCCommande{ + public class InternalddonCCommande implements DiscordCCommande,StringCCommande{ Message m; Laboratory labo; From cad2de01d16c7ca61f7805545e0ad501b8ef28c4 Mon Sep 17 00:00:00 2001 From: Mysaa Date: Sun, 23 May 2021 02:40:44 +0200 Subject: [PATCH 3/3] =?UTF-8?q?Deux=20fichiers=20oubli=C3=A9s=20dans=20le?= =?UTF-8?q?=20commit=20pr=C3=A9c=C3=A9dent?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../bernard/juliabot/JuliaErrPrintStream.java | 60 +++++++++++++++++++ .../com/bernard/juliabot/api/JuliaConfig.java | 40 +++++++++++++ 2 files changed, 100 insertions(+) create mode 100644 src/main/java/com/bernard/juliabot/JuliaErrPrintStream.java create mode 100644 src/main/java/com/bernard/juliabot/api/JuliaConfig.java diff --git a/src/main/java/com/bernard/juliabot/JuliaErrPrintStream.java b/src/main/java/com/bernard/juliabot/JuliaErrPrintStream.java new file mode 100644 index 0000000..e43f2a4 --- /dev/null +++ b/src/main/java/com/bernard/juliabot/JuliaErrPrintStream.java @@ -0,0 +1,60 @@ +package com.bernard.juliabot; + +import java.io.IOException; +import java.io.OutputStream; +import java.io.PrintStream; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + +import net.dv8tion.jda.core.MessageBuilder; +import net.dv8tion.jda.core.entities.MessageChannel; + +public class JuliaErrPrintStream extends OutputStream { + + StringBuilder tas = new StringBuilder(2000);// Les 2000 caractères de Discord + + Lock cadenas; + + MessageChannel logChannel; + + public static final int maxlength = 1900; + + public JuliaErrPrintStream(MessageChannel logChan) { + this.cadenas = new ReentrantLock(); + this.logChannel = logChan; + } + + @Override + public void write(int i) throws IOException { + tas.append((char)(i)); + } + + + @Override + public void flush() { + } + + + + public void flushMessage() { + if(tas.length()==0)return; + this.cadenas.lock(); + String str = tas.toString(); + for(int i = 0; i*maxlength < tas.length();i++) { + MessageBuilder builder = new MessageBuilder(); + builder.appendCodeBlock(str.substring(i*maxlength, Math.min((i+1)*maxlength,tas.length())), ""); + logChannel.sendMessage(builder.build()).queue(); + } + tas = new StringBuilder(); + this.cadenas.unlock(); + + } + + PrintStream ps = null; + public PrintStream printStream() { + if(ps == null) + ps = new PrintStream(this); + return ps; + } + +} diff --git a/src/main/java/com/bernard/juliabot/api/JuliaConfig.java b/src/main/java/com/bernard/juliabot/api/JuliaConfig.java new file mode 100644 index 0000000..0fd072e --- /dev/null +++ b/src/main/java/com/bernard/juliabot/api/JuliaConfig.java @@ -0,0 +1,40 @@ +package com.bernard.juliabot.api; + +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; + +import com.bernard.juliabot.Julia; + +public class JuliaConfig { + + public static final String get(String name) { + try { + PreparedStatement st = Julia.theJulia().getJuliaDatabase().prepareStatement("SELECT * FROM juliaConfig WHERE strID=?"); + st.setString(1, name); + ResultSet r = st.executeQuery(); + if(r.getFetchSize() == 0) + throw new IllegalArgumentException("La configuration "+name+" n'existe pas ... veuillez la rentrer avant de la demander"); + String value = r.getString("value"); + return value; + } catch (SQLException e) { + e.printStackTrace(); + throw new IllegalStateException("Impossible de faire des requetes à la bdd de julia. Est-elle initialisée au moins ?"); + } + } + + public static final void set(String name, String value) { + try { + PreparedStatement st = Julia.theJulia().getJuliaDatabase().prepareStatement("UPDATE juliaConfig SET value=? WHERE strID=?"); + st.setString(1, value); + st.setString(2, value); + int r = st.executeUpdate(); + if(r == 0) + throw new IllegalArgumentException("La configuration "+name+" n'a pas pu être modifiée ... existe-elle ?"); + } catch (SQLException e) { + e.printStackTrace(); + throw new IllegalStateException("Impossible de faire des requetes à la bdd de julia. Est-elle initialisée au moins ?"); + } + } + +}