diff --git a/src/main/java/com/bernard/juliabot/EcouteurDEvents.java b/src/main/java/com/bernard/juliabot/EcouteurDEvents.java index 4d4f5db..a4171a7 100644 --- a/src/main/java/com/bernard/juliabot/EcouteurDEvents.java +++ b/src/main/java/com/bernard/juliabot/EcouteurDEvents.java @@ -4,14 +4,10 @@ import java.io.*; import java.nio.charset.StandardCharsets; import java.sql.*; import java.time.Instant; -import java.util.Date; -import java.util.List; -import java.util.Queue; +import java.util.*; import java.util.concurrent.ConcurrentLinkedQueue; import java.util.stream.Collectors; -import com.mysql.cj.exceptions.ExceptionInterceptor; -import com.mysql.cj.exceptions.ExceptionInterceptorChain; import com.mysql.cj.jdbc.Blob; import net.dv8tion.jda.client.events.call.GenericCallEvent; @@ -20,22 +16,34 @@ import net.dv8tion.jda.client.events.message.group.GenericGroupMessageEvent; import net.dv8tion.jda.client.events.relationship.GenericRelationshipEvent; import net.dv8tion.jda.core.entities.*; import net.dv8tion.jda.core.events.*; -import net.dv8tion.jda.core.events.channel.category.GenericCategoryEvent; +import net.dv8tion.jda.core.events.channel.category.*; import net.dv8tion.jda.core.events.channel.category.update.*; import net.dv8tion.jda.core.events.channel.priv.PrivateChannelCreateEvent; import net.dv8tion.jda.core.events.channel.priv.PrivateChannelDeleteEvent; -import net.dv8tion.jda.core.events.channel.text.GenericTextChannelEvent; -import net.dv8tion.jda.core.events.channel.voice.GenericVoiceChannelEvent; -import net.dv8tion.jda.core.events.emote.GenericEmoteEvent; -import net.dv8tion.jda.core.events.guild.GenericGuildEvent; -import net.dv8tion.jda.core.events.guild.voice.GenericGuildVoiceEvent; +import net.dv8tion.jda.core.events.channel.text.*; +import net.dv8tion.jda.core.events.channel.text.update.*; +import net.dv8tion.jda.core.events.channel.voice.*; +import net.dv8tion.jda.core.events.channel.voice.update.*; +import net.dv8tion.jda.core.events.emote.*; +import net.dv8tion.jda.core.events.emote.update.EmoteUpdateNameEvent; +import net.dv8tion.jda.core.events.emote.update.EmoteUpdateRolesEvent; +import net.dv8tion.jda.core.events.guild.*; +import net.dv8tion.jda.core.events.guild.member.*; +import net.dv8tion.jda.core.events.guild.update.*; +import net.dv8tion.jda.core.events.guild.voice.*; import net.dv8tion.jda.core.events.message.GenericMessageEvent; import net.dv8tion.jda.core.events.message.MessageBulkDeleteEvent; -import net.dv8tion.jda.core.events.message.guild.GenericGuildMessageEvent; -import net.dv8tion.jda.core.events.message.priv.GenericPrivateMessageEvent; -import net.dv8tion.jda.core.events.message.react.MessageReactionAddEvent; -import net.dv8tion.jda.core.events.role.GenericRoleEvent; +import net.dv8tion.jda.core.events.message.guild.*; +import net.dv8tion.jda.core.events.message.guild.react.*; +import net.dv8tion.jda.core.events.message.priv.*; +import net.dv8tion.jda.core.events.message.priv.react.PrivateMessageReactionAddEvent; +import net.dv8tion.jda.core.events.message.priv.react.PrivateMessageReactionRemoveEvent; +import net.dv8tion.jda.core.events.role.*; +import net.dv8tion.jda.core.events.role.update.*; +import net.dv8tion.jda.core.events.self.*; import net.dv8tion.jda.core.events.user.GenericUserEvent; +import net.dv8tion.jda.core.events.user.UserTypingEvent; +import net.dv8tion.jda.core.events.user.update.*; import net.dv8tion.jda.core.hooks.EventListener; public class EcouteurDEvents implements EventListener{ @@ -44,25 +52,29 @@ public class EcouteurDEvents implements EventListener{ Thread looper; - public EcouteurDEvents() { + Julia julia; + + public EcouteurDEvents(Julia julia) { + this.julia = julia; ResultSet results; try { - Statement geidS = Julia.theJulia.eventDatabase.createStatement(); + Statement geidS = julia.eventDatabase.createStatement(); results = geidS.executeQuery("SELECT MAX(GEID) FROM events"); + 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'écents ne démarera pas"); + System.err.println("IMPOSSIBLE de récuperer le MAX_GEID : L'Écouteur d'évents ne démarera pas"); e.printStackTrace(); } } @Override public void onEvent(Event event) { - storeQueue.add(new PendingEventStore(event,Date.from(Instant.now()))); - Julia.theJulia.laboratoires.get(getLabo(event)).trigger(event); + storeQueue.add(new PendingEventStore(event,Timestamp.from(Instant.now()))); + this.julia.laboratoires.get(getLabo(event)).trigger(event); } public char getLabo(Event e) { @@ -110,12 +122,16 @@ public class EcouteurDEvents implements EventListener{ } public Character g(Long id) { - return Julia.theJulia.laboratoriesIdentifieurs.getOrDefault(id, '#'); + return this.julia.laboratoriesIdentifieurs.getOrDefault(id, '#'); } public class DbLooper implements Runnable{ - boolean stop = false; + byte state = 0b0000; + //1:shouldStop, LSB + //2:hasStopped + //3:shouldPause + //4:hasPaused, HSB public long indexGEID; @@ -126,7 +142,8 @@ public class EcouteurDEvents implements EventListener{ @Override public void run() { - while(!stop) { + state &= 0b1101; + while((state&0b0001)==0) { if(storeQueue.isEmpty()) { try { @@ -140,117 +157,879 @@ public class EcouteurDEvents implements EventListener{ storeEvent(pes.e, pes.eTime); } + /// PAUSE MODULE + while((state&0b0100)!=0) { + state |= 0b1000; + try { + Thread.sleep(10); + } catch (InterruptedException e) { + System.err.println("Impossible de faire dormir le thread ... On va donc continuer de looper sans pause la pause ..."); + e.printStackTrace(); + } + } + /// END PAUSE MODULE } + + state |= 0b0010; } - public void storeEvent(Event event,Date date) { + public void requestPause() { + state |= 0b0100; + } + public void requestPlay() { + state &= 0b1011; + } + public void requestStop() { + state |= 0b0001; + } + public boolean hasStopped() { + return (state & 0b0010) == 0; + } + public boolean isPaused() { + return (state & 0b1000) == 0; + } + + public void storeEvent(Event event,Timestamp date) { + if(GenericMessageEvent.class.isAssignableFrom(event.getClass()))return;//Event non loggé PreparedStatement s; - Connection db = Julia.theJulia.eventDatabase; + Connection db = EcouteurDEvents.this.julia.eventDatabase; try { long geid = indexGEID++; - //TODO store event GEID PreparedStatement geidS = db.prepareStatement("INSERT INTO events VALUES (?,?,?,?)"); geidS.setLong(1, geid); - geidS.setDate(2, new java.sql.Date(date.getTime())); + geidS.setTimestamp(2, date); geidS.setLong(3, event.getResponseNumber()); geidS.setString(4, event.getClass().getName()); geidS.executeUpdate(); - String tName = l1(event.getClass().getSimpleName()); switch(event.getClass().getSimpleName()) { - /////////// GenericCategoryEvent /////////// - case "CategoryUpdatePermissionsEvent": - addPermissionHolders(geid,((CategoryUpdatePermissionsEvent)event).getChangedPermissionHolders(),); - case "CategoryCreateEvent": - case "CategoryDeleteEvent": - GenericCategoryEvent e1 = (GenericCategoryEvent) event; - s = db.prepareStatement("INSERT INTO "+tName+" VALUES (?,?,?)"); - s.setLong(2, e1.getGuild().getIdLong()); - s.setLong(3, e1.getIdLong()); - break; - case "CategoryUpdateNameEvent": - CategoryUpdateNameEvent e2 = (CategoryUpdateNameEvent) event; - s = db.prepareStatement("INSERT INTO "+tName+" VALUES (?,?,?,?,?)"); - s.setLong(2, e2.getGuild().getIdLong()); - s.setLong(3, e2.getIdLong()); - s.setString(4, e2.getOldName()); - s.setString(5, e2.getNewName()); - break; - case "CategoryUpdatePositionEvent": - CategoryUpdatePositionEvent e3 = (CategoryUpdatePositionEvent) event; - s = db.prepareStatement("INSERT INTO "+tName+" VALUES (?,?,?,?,?)"); - s.setLong(2, e3.getGuild().getIdLong()); - s.setLong(3, e3.getIdLong()); - s.setInt(4, e3.getOldPosition()); - s.setInt(5, e3.getNewPosition()); - break; - + ////////// Events ////////// case "DisconnectEvent": DisconnectEvent e4 = (DisconnectEvent)event; s = db.prepareStatement("INSERT INTO disconnectEvent VALUES (?,?,?,?,?,?,?)"); - s.setBlob(2, new Blob(e4.getClientCloseFrame().getPayload(),null)); - s.setString(3, e4.getCloseCode().name()); + s.setBlob(2, new Blob((e4.getClientCloseFrame()==null)?new byte[0]:((e4.getServiceCloseFrame().getPayload())== null?new byte[0]:e4.getServiceCloseFrame().getPayload()),null)); + s.setString(3, (e4.getCloseCode()==null)?null:e4.getCloseCode().name()); s.setDate(4, new java.sql.Date(e4.getDisconnectTime().toEpochSecond())); - s.setBlob(5, new Blob(e4.getServiceCloseFrame().getPayload(),null)); + s.setBlob(5, new Blob((e4.getServiceCloseFrame().getPayload()==null)?new byte[0]:e4.getServiceCloseFrame().getPayload(),null)); s.setBoolean(6, e4.isClosedByServer()); s.setString(7, String.join("\n", e4.getCloudflareRays())); - + break; + case "ExceptionEvent": ExceptionEvent e5 = (ExceptionEvent)event; s = db.prepareStatement("INSERT INTO exceptionEvent VALUES (?,?,?,?,?,?,?)"); s.setString(2, e5.getCause().getClass().getName()); s.setString(3, e5.getCause().getMessage()); - StringWriter sw = new StringWriter(); final ByteArrayOutputStream baos = new ByteArrayOutputStream(); try (PrintStream ps = new PrintStream(baos, true, "UTF-8")) { e5.getCause().printStackTrace(ps); - } - String data = new String(baos.toByteArray(), StandardCharsets.UTF_8); - s.setDate(4, new java.sql.Date(e4.getDisconnectTime().toEpochSecond())); - s.setBlob(5, new Blob(e4.getServiceCloseFrame().getPayload(),null)); - s.setBoolean(6, e4.isClosedByServer()); - s.setString(7, String.join("\n", e4.getCloudflareRays())); - - - - - - case "MessageReactionAddEvent": - MessageReactionAddEvent e = (MessageReactionAddEvent) event; - s = db.prepareStatement("INSERT INTO messageReactionAdd VALUES (?,?,?,?,?,?,?,?,?,?)"); - - s.setLong(4, e.getMessageIdLong()); - s.setLong(5, e.getChannel().getIdLong()); - s.setLong(6, e.getGuild().getIdLong()); - s.setLong(7, e.getUser().getIdLong()); - s.setInt(8, e.getReaction().getCount()); - s.setString(9, e.getReactionEmote().getName()); - s.setLong(10, e.getReactionEmote().getIdLong()); + } catch (UnsupportedEncodingException error) { + error.printStackTrace(); + + } + s.setString(4, new String(baos.toByteArray(), StandardCharsets.UTF_8)); + s.setBoolean(5, e5.isLogged()); + break; + + case "ReadyEvent": + ReadyEvent e6 = (ReadyEvent)event; + s = db.prepareStatement("INSERT INTO readyEvent VALUES (?,?,?)"); + s.setInt(2, e6.getGuildAvailableCount()); + s.setInt(3, e6.getGuildUnavailableCount()); + break; + case "ResumedEvent": + s = db.prepareStatement("INSERT INTO resumedEvent VALUES (?)"); + break; + case "ReconnectedEvent": + s = db.prepareStatement("INSERT INTO reconnectedEvent VALUES (?)"); + break; + case "ShutdownEvent": + ShutdownEvent e7 = (ShutdownEvent)event; + s = db.prepareStatement("INSERT INTO shutdownEvent VALUES (?,?,?)"); + s.setTimestamp(2, new Timestamp(e7.getShutdownTime().toEpochSecond())); + s.setString(3, e7.getCloseCode().name()); + break; + case "StatusChangeEvent": + StatusChangeEvent e8 = (StatusChangeEvent)event; + s = db.prepareStatement("INSERT INTO statusChangeEvent VALUES (?,?,?,?)"); + s.setString(2, e8.getPropertyIdentifier()); + s.setString(3, e8.getOldStatus().name()); + s.setString(4, e8.getNewStatus().name()); break; - + ////////// GenericSelfUpdateEvent ////////// + case "SelfUpdateAvatarEvent": + SelfUpdateAvatarEvent e9 = (SelfUpdateAvatarEvent)event; + s = db.prepareStatement("INSERT INTO selfUpdateAvatarEvent VALUES (?,?,?,?)"); + s.setLong(2, addSelfUser(e9.getSelfUser(), db)); + s.setString(3, e9.getOldAvatarUrl()); + s.setString(4, e9.getNewAvatarUrl()); + break; + case "SelfUpdateDiscriminatorEvent": + SelfUpdateDiscriminatorEvent e10 = (SelfUpdateDiscriminatorEvent)event; + s = db.prepareStatement("INSERT INTO selfUpdateDiscriminatorEvent VALUES (?,?,?,?)"); + s.setLong(2, addSelfUser(e10.getSelfUser(), db)); + s.setString(3, e10.getOldDiscriminator()); + s.setString(4, e10.getNewDiscriminator()); + break; + case "SelfUpdateEmailEvent": + SelfUpdateEmailEvent e11 = (SelfUpdateEmailEvent)event; + s = db.prepareStatement("INSERT INTO selfUpdateEmailEvent VALUES (?,?,?,?)"); + s.setLong(2, addSelfUser(e11.getSelfUser(), db)); + s.setString(3, e11.getOldEmail()); + s.setString(4, e11.getNewEmail()); + break; + case "SelfUpdateMFAEvent": + SelfUpdateMFAEvent e14 = (SelfUpdateMFAEvent)event; + s = db.prepareStatement("INSERT INTO selfUpdateMFAEvent VALUES (?,?,?)"); + s.setLong(2, addSelfUser(e14.getSelfUser(), db)); + s.setBoolean(3, e14.wasMfaEnabled()); + break; + case "SelfUpdateMobileEvent": + SelfUpdateMobileEvent e15 = (SelfUpdateMobileEvent)event; + s = db.prepareStatement("INSERT INTO selfUpdateMobileEvent VALUES (?,?,?)"); + s.setLong(2, addSelfUser(e15.getSelfUser(), db)); + s.setBoolean(3, e15.wasMobile()); + break; + case "SelfUpdateNameEvent": + SelfUpdateNameEvent e12 = (SelfUpdateNameEvent)event; + s = db.prepareStatement("INSERT INTO selfUpdateNameEvent VALUES (?,?,?,?)"); + s.setLong(2, addSelfUser(e12.getSelfUser(), db)); + s.setString(3, e12.getOldName()); + s.setString(4, e12.getNewName()); + break; + case "SelfUpdateNitroEvent": + SelfUpdateNitroEvent e16 = (SelfUpdateNitroEvent)event; + s = db.prepareStatement("INSERT INTO selfUpdateNitroEvent VALUES (?,?,?)"); + s.setLong(2, addSelfUser(e16.getSelfUser(), db)); + s.setBoolean(3, e16.wasNitro()); + break; + case "SelfUpdatePhoneNumberEvent": + SelfUpdatePhoneNumberEvent e13 = (SelfUpdatePhoneNumberEvent)event; + s = db.prepareStatement("INSERT INTO selfUpdatePhoneNumberEvent VALUES (?,?,?,?)"); + s.setLong(2, addSelfUser(e13.getSelfUser(), db)); + s.setString(3, e13.getOldPhoneNumber()); + s.setString(4, e13.getNewPhoneNumber()); + break; + case "SelfUpdateVerifiedEvent": + SelfUpdateVerifiedEvent e17 = (SelfUpdateVerifiedEvent)event; + s = db.prepareStatement("INSERT INTO selfUpdateVerifiedEvent VALUES (?,?,?)"); + s.setLong(2, addSelfUser(e17.getSelfUser(), db)); + s.setBoolean(3, e17.wasVerified()); + break; - default: throw new IllegalStateException("Cette méthode n'est pas a jour avec le JDA ... je gère pas "+event.getClass().getName()); + + ////////// GenericUserEvent ////////// + case "UserTypingEvent": + UserTypingEvent e18 = (UserTypingEvent)event; + s = db.prepareStatement("INSERT INTO userTypingEvent VALUES (?,?,?,?)"); + s.setLong(2, e18.getUser().getIdLong()); + s.setLong(3, e18.getGuild().getIdLong()); + s.setLong(4, e18.getChannel().getIdLong()); + break; + case "UserUpdateNameEvent": + UserUpdateNameEvent e19 = (UserUpdateNameEvent)event; + s = db.prepareStatement("INSERT INTO userUpdateNameEvent VALUES (?,?,?,?)"); + s.setLong(2, e19.getUser().getIdLong()); + s.setString(3, e19.getOldName()); + s.setString(4, e19.getNewName()); + break; + case "UserUpdateDiscriminatorEvent": + UserUpdateDiscriminatorEvent e20 = (UserUpdateDiscriminatorEvent)event; + s = db.prepareStatement("INSERT INTO userUpdateDiscriminatorEvent VALUES (?,?,?,?)"); + s.setLong(2, e20.getUser().getIdLong()); + s.setString(3, e20.getOldDiscriminator()); + s.setString(4, e20.getNewDiscriminator()); + break; + case "UserUpdateAvatarEvent": + UserUpdateAvatarEvent e21 = (UserUpdateAvatarEvent)event; + s = db.prepareStatement("INSERT INTO userUpdateAvatarEvent VALUES (?,?,?,?)"); + s.setLong(2, e21.getUser().getIdLong()); + s.setString(3, e21.getOldAvatarUrl()); + s.setString(4, e21.getNewAvatarUrl()); + break; + case "UserUpdateOnlineStatusEvent": + UserUpdateOnlineStatusEvent e22 = (UserUpdateOnlineStatusEvent)event; + s = db.prepareStatement("INSERT INTO userUpdateOnlineStatusEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e22.getUser().getIdLong()); + s.setLong(3, e22.getGuild().getIdLong()); + s.setString(4, e22.getOldOnlineStatus().name()); + s.setString(5, e22.getNewOnlineStatus().name()); + break; + case "UserUpdateGameEvent": + UserUpdateGameEvent e23 = (UserUpdateGameEvent)event; + s = db.prepareStatement("INSERT INTO userUpdateGameEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e23.getUser().getIdLong()); + s.setLong(3, e23.getGuild().getIdLong()); + s.setObject(4, addGame(e23.getOldGame(), db)); + s.setObject(5, addGame(e23.getNewGame(), db)); + break; + + + ////////// GenericPrivateMessageEvent ////////// + case "PrivateMessageDeleteEvent": + PrivateMessageDeleteEvent e24 = (PrivateMessageDeleteEvent)event; + s = db.prepareStatement("INSERT INTO privateMessageDeleteEvent VALUES (?,?,?)"); + s.setLong(2, e24.getChannel().getIdLong()); + s.setLong(3, e24.getMessageIdLong()); + break; + case "PrivateMessageEmbedEvent": + PrivateMessageEmbedEvent e25 = (PrivateMessageEmbedEvent)event; + addEmbedMessage(geid, e25.getMessageEmbeds(), db); + s = db.prepareStatement("INSERT INTO privateMessageEmbedEvent VALUES (?,?,?)"); + s.setLong(2, e25.getChannel().getIdLong()); + s.setLong(3, e25.getMessageIdLong()); + break; + case "PrivateMessageReceivedEvent": + PrivateMessageReceivedEvent e26 = (PrivateMessageReceivedEvent)event; + int mID26 = addMessage(e26.getMessage(), db); + s = db.prepareStatement("INSERT INTO privateMessageReceivedEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e26.getAuthor().getIdLong()); + s.setLong(3, e26.getChannel().getIdLong()); + s.setLong(4, e26.getMessageIdLong()); + s.setInt(5, mID26); + break; + case "PrivateMessageUpdateEvent": + PrivateMessageUpdateEvent e27 = (PrivateMessageUpdateEvent)event; + int mID27 = addMessage(e27.getMessage(), db); + s = db.prepareStatement("INSERT INTO privateMessageUpdateEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e27.getAuthor().getIdLong()); + s.setLong(3, e27.getChannel().getIdLong()); + s.setLong(4, e27.getMessageIdLong()); + s.setInt(5, mID27); + break; + case "PrivateMessageReactionAddEvent": + PrivateMessageReactionAddEvent e28 = (PrivateMessageReactionAddEvent)event; + int mID28 = addMessageReaction(e28.getReaction(), db); + s = db.prepareStatement("INSERT INTO privateMessageReactionAddEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e28.getChannel().getIdLong()); + s.setLong(3, e28.getMessageIdLong()); + s.setLong(4, e28.getUser().getIdLong()); + s.setInt(5, mID28); + break; + case "PrivateMessageReactionRemoveEvent": + PrivateMessageReactionRemoveEvent e29 = (PrivateMessageReactionRemoveEvent)event; + int mID29 = addMessageReaction(e29.getReaction(), db); + s = db.prepareStatement("INSERT INTO privateMessageReactionRemoveEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e29.getChannel().getIdLong()); + s.setLong(3, e29.getMessageIdLong()); + s.setLong(4, e29.getUser().getIdLong()); + s.setInt(5, mID29); + break; + + + ////////// GenericGuildEvent ////////// + case "GuildReadyEvent": + GuildReadyEvent e30 = (GuildReadyEvent)event; + s = db.prepareStatement("INSERT INTO guildReadyEvent VALUES (?,?)"); + s.setLong(2, e30.getGuild().getIdLong()); + break; + case "GuildAvailableEvent": + GuildAvailableEvent e31 = (GuildAvailableEvent)event; + s = db.prepareStatement("INSERT INTO guildAvailableEvent VALUES (?,?)"); + s.setLong(2, e31.getGuild().getIdLong()); + break; + case "GuildBanEvent": + GuildBanEvent e32 = (GuildBanEvent)event; + s = db.prepareStatement("INSERT INTO guildBanEvent VALUES (?,?,?)"); + s.setLong(2, e32.getGuild().getIdLong()); + s.setLong(3, e32.getUser().getIdLong()); + break; + case "GuildJoinEvent": + GuildJoinEvent e33 = (GuildJoinEvent)event; + s = db.prepareStatement("INSERT INTO guildJoinEvent VALUES (?,?)"); + s.setLong(2, e33.getGuild().getIdLong()); + break; + case "GuildLeaveEvent": + GuildLeaveEvent e34 = (GuildLeaveEvent)event; + s = db.prepareStatement("INSERT INTO guildLeaveEvent VALUES (?,?)"); + s.setLong(2, e34.getGuild().getIdLong()); + break; + case "GuildUnavailableEvent": + GuildUnavailableEvent e35 = (GuildUnavailableEvent)event; + s = db.prepareStatement("INSERT INTO guildUnavailableEvent VALUES (?,?)"); + s.setLong(2, e35.getGuild().getIdLong()); + break; + case "GuildUnbanEvent": + GuildUnbanEvent e36 = (GuildUnbanEvent)event; + s = db.prepareStatement("INSERT INTO guildUnanEvent VALUES (?,?,?)"); + s.setLong(2, e36.getGuild().getIdLong()); + s.setLong(3, e36.getUser().getIdLong()); + break; + + case "GuildMessageDeleteEvent": + GuildMessageDeleteEvent e37 = (GuildMessageDeleteEvent)event; + s = db.prepareStatement("INSERT INTO guildMessageDeleteEvent VALUES (?,?,?)"); + s.setLong(2, e37.getChannel().getIdLong()); + s.setLong(3, e37.getMessageIdLong()); + break; + case "GuildMessageEmbedEvent": + GuildMessageEmbedEvent e38 = (GuildMessageEmbedEvent)event; + addEmbedMessage(geid, e38.getMessageEmbeds(), db); + s = db.prepareStatement("INSERT INTO guildMessageEmbedEvent VALUES (?,?,?)"); + s.setLong(2, e38.getChannel().getIdLong()); + s.setLong(3, e38.getMessageIdLong()); + break; + case "GuildMessageReceivedEvent": + GuildMessageReceivedEvent e39 = (GuildMessageReceivedEvent)event; + int mID39 = addMessage(e39.getMessage(), db); + s = db.prepareStatement("INSERT INTO guildMessageReceivedEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e39.getAuthor().getIdLong()); + s.setLong(3, e39.getChannel().getIdLong()); + s.setLong(4, e39.getMessageIdLong()); + s.setInt(5, mID39); + break; + case "GuildMessageUpdateEvent": + GuildMessageUpdateEvent e40 = (GuildMessageUpdateEvent)event; + int mID40 = addMessage(e40.getMessage(), db); + s = db.prepareStatement("INSERT INTO guildMessageUpdateEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e40.getAuthor().getIdLong()); + s.setLong(3, e40.getChannel().getIdLong()); + s.setLong(4, e40.getMessageIdLong()); + s.setInt(5, mID40); + break; + case "GuildMessageReactionRemoveAllEvent": + GuildMessageReactionRemoveAllEvent e40b = (GuildMessageReactionRemoveAllEvent)event; + s = db.prepareStatement("INSERT INTO guildMessageReactionRemoveAllEvent VALUES (?,?,?)"); + s.setLong(2, e40b.getChannel().getIdLong()); + s.setLong(3, e40b.getMessageIdLong()); + break; + case "GuildMessageReactionAddEvent": + GuildMessageReactionAddEvent e41 = (GuildMessageReactionAddEvent)event; + int mID41 = addMessageReaction(e41.getReaction(), db); + s = db.prepareStatement("INSERT INTO guildMessageReactionAddEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e41.getChannel().getIdLong()); + s.setLong(3, e41.getMessageIdLong()); + s.setLong(4, e41.getUser().getIdLong()); + s.setInt(5, mID41); + break; + case "GuildMessageReactionRemoveEvent": + GuildMessageReactionRemoveEvent e42 = (GuildMessageReactionRemoveEvent)event; + int mID42 = addMessageReaction(e42.getReaction(), db); + s = db.prepareStatement("INSERT INTO guildMessageReactionRemoveEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e42.getChannel().getIdLong()); + s.setLong(3, e42.getMessageIdLong()); + s.setLong(4, e42.getUser().getIdLong()); + s.setInt(5, mID42); + break; + + case "GuildUpdateAfkChannelEvent": + GuildUpdateAfkChannelEvent e43 = (GuildUpdateAfkChannelEvent)event; + s = db.prepareStatement("INSERT INTO guildUpdateAfkChannelEvent VALUES (?,?,?,?)"); + s.setLong(2, e43.getGuild().getIdLong()); + s.setLong(3, e43.getOldAfkChannel().getIdLong()); + s.setLong(4, e43.getNewAfkChannel().getIdLong()); + break; + case "GuildUpdateAfkTimeoutEvent": + GuildUpdateAfkTimeoutEvent e44 = (GuildUpdateAfkTimeoutEvent)event; + s = db.prepareStatement("INSERT INTO guildUpdateAfkTimeoutEvent VALUES (?,?,?,?)"); + s.setLong(2, e44.getGuild().getIdLong()); + s.setString(3, e44.getOldAfkTimeout().name()); + s.setString(4, e44.getNewAfkTimeout().name()); + break; + case "GuildUpdateExplicitContentLevelEvent": + GuildUpdateExplicitContentLevelEvent e45 = (GuildUpdateExplicitContentLevelEvent)event; + s = db.prepareStatement("INSERT INTO guildUpdateExplicitContentLevelEvent VALUES (?,?,?,?)"); + s.setLong(2, e45.getGuild().getIdLong()); + s.setString(3, e45.getOldLevel().name()); + s.setString(4, e45.getNewLevel().name()); + break; + case "GuildUpdateFeaturesEvent": + GuildUpdateFeaturesEvent e46 = (GuildUpdateFeaturesEvent)event; + s = db.prepareStatement("INSERT INTO guildUpdateFeaturesEvent VALUES (?,?,?,?)"); + s.setLong(2, e46.getGuild().getIdLong()); + s.setString(3, String.join(",",e46.getOldFeatures())); + s.setString(4, String.join(",",e46.getNewFeatures())); + break; + case "GuildUpdateIconEvent": + GuildUpdateIconEvent e47 = (GuildUpdateIconEvent)event; + s = db.prepareStatement("INSERT INTO guildUpdateIconEvent VALUES (?,?,?,?,?,?)"); + s.setLong(2, e47.getGuild().getIdLong()); + s.setString(3, e47.getOldIconUrl()); + s.setString(4, e47.getOldIconId()); + s.setString(5, e47.getNewIconUrl()); + s.setString(6, e47.getNewIconId()); + break; + case "GuildUpdateMFALevelEvent": + GuildUpdateMFALevelEvent e48 = (GuildUpdateMFALevelEvent)event; + s = db.prepareStatement("INSERT INTO guildUpdateMFALevelEvent VALUES (?,?,?,?)"); + s.setLong(2, e48.getGuild().getIdLong()); + s.setString(3, e48.getOldMFALevel().name()); + s.setString(4, e48.getNewMFALevel().name()); + break; + case "GuildUpdateNameEvent": + GuildUpdateNameEvent e49 = (GuildUpdateNameEvent)event; + s = db.prepareStatement("INSERT INTO guildUpdateNameEvent VALUES (?,?,?,?)"); + s.setLong(2, e49.getGuild().getIdLong()); + s.setString(3, e49.getOldName()); + s.setString(4, e49.getNewName()); + break; + case "GuildUpdateNotificationLevelEvent": + GuildUpdateNotificationLevelEvent e50 = (GuildUpdateNotificationLevelEvent)event; + s = db.prepareStatement("INSERT INTO guildUpdateNotificationLevelEvent VALUES (?,?,?,?)"); + s.setLong(2, e50.getGuild().getIdLong()); + s.setString(3, e50.getOldNotificationLevel().name()); + s.setString(4, e50.getNewNotificationLevel().name()); + break; + case "GuildUpdateOwnerEvent": + GuildUpdateOwnerEvent e51 = (GuildUpdateOwnerEvent)event; + s = db.prepareStatement("INSERT INTO guildUpdateOwnerEvent VALUES (?,?,?,?)"); + s.setLong(2, e51.getGuild().getIdLong()); + s.setLong(3, e51.getOldOwner().getUser().getIdLong()); + s.setLong(4, e51.getNewOwner().getUser().getIdLong()); + break; + case "GuildUpdateRegionEvent": + GuildUpdateRegionEvent e52 = (GuildUpdateRegionEvent)event; + s = db.prepareStatement("INSERT INTO guildUpdateRegionEvent VALUES (?,?,?,?)"); + s.setLong(2, e52.getGuild().getIdLong()); + s.setString(3, e52.getOldRegion().name()); + s.setString(4, e52.getNewRegion().name()); + break; + case "GuildUpdateSplashEvent": + GuildUpdateSplashEvent e53 = (GuildUpdateSplashEvent)event; + s = db.prepareStatement("INSERT INTO guildUpdateSplashEvent VALUES (?,?,?,?)"); + s.setLong(2, e53.getGuild().getIdLong()); + s.setString(3, e53.getOldSplashUrl()); + s.setString(4, e53.getOldSplashId()); + s.setString(5, e53.getNewSplashUrl()); + s.setString(6, e53.getNewSplashId()); + break; + case "GuildUpdateSystemChannelEvent": + GuildUpdateSystemChannelEvent e54 = (GuildUpdateSystemChannelEvent)event; + s = db.prepareStatement("INSERT INTO guildUpdateSystemChannelEvent VALUES (?,?,?,?)"); + s.setLong(2, e54.getGuild().getIdLong()); + s.setLong(3, e54.getOldSystemChannel().getIdLong()); + s.setLong(4, e54.getNewSystemChannel().getIdLong()); + break; + case "GuildUpdateVerificationLevelEvent": + GuildUpdateVerificationLevelEvent e55 = (GuildUpdateVerificationLevelEvent)event; + s = db.prepareStatement("INSERT INTO guildUpdateVerificationLevelEvent VALUES (?,?,?,?)"); + s.setLong(2, e55.getGuild().getIdLong()); + s.setString(3, e55.getOldVerificationLevel().name()); + s.setString(4, e55.getNewVerificationLevel().name()); + break; + + case "GuildMemberJoinEvent": + GuildMemberJoinEvent e56 = (GuildMemberJoinEvent)event; + s = db.prepareStatement("INSERT INTO guildMemberJoinEvent VALUES (?,?,?)"); + s.setLong(2, e56.getGuild().getIdLong()); + s.setLong(3, e56.getUser().getIdLong()); + break; + case "GuildMemberNickChangeEvent": + GuildMemberNickChangeEvent e57 = (GuildMemberNickChangeEvent)event; + s = db.prepareStatement("INSERT INTO guildMemberNickChangeEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e57.getGuild().getIdLong()); + s.setLong(3, e57.getUser().getIdLong()); + s.setString(4, e57.getPrevNick()); + s.setString(5, e57.getNewNick()); + break; + case "GuildMemberLeaveEvent": + GuildMemberLeaveEvent e58 = (GuildMemberLeaveEvent)event; + s = db.prepareStatement("INSERT INTO guildMemberLeaveEvent VALUES (?,?,?)"); + s.setLong(2, e58.getGuild().getIdLong()); + s.setLong(3, e58.getUser().getIdLong()); + break; + case "GuildMemberRoleAddEvent": + GuildMemberRoleAddEvent e59 = (GuildMemberRoleAddEvent)event; + addRoles(geid, e59.getRoles(), db); + s = db.prepareStatement("INSERT INTO guildMemberRoleAddEvent VALUES (?,?,?)"); + s.setLong(2, e59.getGuild().getIdLong()); + s.setLong(3, e59.getUser().getIdLong()); + break; + case "GuildMemberRoleRemoveEvent": + GuildMemberRoleRemoveEvent e60 = (GuildMemberRoleRemoveEvent)event; + addRoles(geid, e60.getRoles(), db); + s = db.prepareStatement("INSERT INTO guildMemberRoleRemoveEvent VALUES (?,?,?)"); + s.setLong(2, e60.getGuild().getIdLong()); + s.setLong(3, e60.getUser().getIdLong()); + break; + + case "GuildVoiceDeafenEvent": + GuildVoiceDeafenEvent e61 = (GuildVoiceDeafenEvent)event; + s = db.prepareStatement("INSERT INTO guildVoiceDeafenEvent VALUES (?,?,?,?)"); + s.setLong(2, e61.getGuild().getIdLong()); + s.setLong(3, e61.getMember().getUser().getIdLong()); + s.setBoolean(4, e61.isDeafened()); + break; + case "GuildVoiceGuildDeafenEvent": + GuildVoiceGuildDeafenEvent e62 = (GuildVoiceGuildDeafenEvent)event; + s = db.prepareStatement("INSERT INTO guildVoiceGuildDeafenEvent VALUES (?,?,?,?)"); + s.setLong(2, e62.getGuild().getIdLong()); + s.setLong(3, e62.getMember().getUser().getIdLong()); + s.setBoolean(4, e62.isGuildDeafened()); + break; + case "GuildVoiceGuildMuteEvent": + GuildVoiceGuildMuteEvent e63 = (GuildVoiceGuildMuteEvent)event; + s = db.prepareStatement("INSERT INTO guildVoiceGuildMuteEvent VALUES (?,?,?,?)"); + s.setLong(2, e63.getGuild().getIdLong()); + s.setLong(3, e63.getMember().getUser().getIdLong()); + s.setBoolean(4, e63.isGuildMuted()); + break; + case "GuildVoiceMuteEvent": + GuildVoiceMuteEvent e64 = (GuildVoiceMuteEvent)event; + s = db.prepareStatement("INSERT INTO guildVoiceMuteEvent VALUES (?,?,?,?)"); + s.setLong(2, e64.getGuild().getIdLong()); + s.setLong(3, e64.getMember().getUser().getIdLong()); + s.setBoolean(4, e64.isMuted()); + break; + case "GuildVoiceSelfDeafenEvent": + GuildVoiceSelfDeafenEvent e64b = (GuildVoiceSelfDeafenEvent)event; + s = db.prepareStatement("INSERT INTO guildVoiceSelfDeafenEvent VALUES (?,?,?,?)"); + s.setLong(2, e64b.getGuild().getIdLong()); + s.setLong(3, e64b.getMember().getUser().getIdLong()); + s.setBoolean(4, e64b.isSelfDeafened()); + break; + case "GuildVoiceSelfMuteEvent": + GuildVoiceSelfMuteEvent e65 = (GuildVoiceSelfMuteEvent)event; + s = db.prepareStatement("INSERT INTO guildVoiceSelfMuteEvent VALUES (?,?,?,?)"); + s.setLong(2, e65.getGuild().getIdLong()); + s.setLong(3, e65.getMember().getUser().getIdLong()); + s.setBoolean(4, e65.isSelfMuted()); + break; + case "GuildVoiceSuppressEvent": + GuildVoiceSuppressEvent e66 = (GuildVoiceSuppressEvent)event; + s = db.prepareStatement("INSERT INTO guildVoiceSuppressEvent VALUES (?,?,?,?)"); + s.setLong(2, e66.getGuild().getIdLong()); + s.setLong(3, e66.getMember().getUser().getIdLong()); + s.setBoolean(4, e66.isSuppressed()); + break; + case "GuildVoiceJoinEvent": + GuildVoiceJoinEvent e67 = (GuildVoiceJoinEvent)event; + s = db.prepareStatement("INSERT INTO guildVoiceJoinEvent VALUES (?,?,?,?)"); + s.setLong(2, e67.getGuild().getIdLong()); + s.setLong(3, e67.getMember().getUser().getIdLong()); + s.setLong(4, e67.getChannelJoined().getIdLong()); + break; + case "GuildVoiceLeaveEvent": + GuildVoiceLeaveEvent e68 = (GuildVoiceLeaveEvent)event; + s = db.prepareStatement("INSERT INTO guildVoiceLeaveEvent VALUES (?,?,?,?)"); + s.setLong(2, e68.getGuild().getIdLong()); + s.setLong(3, e68.getMember().getUser().getIdLong()); + s.setLong(4, e68.getChannelLeft().getIdLong()); + break; + case "GuildVoiceMoveEvent": + GuildVoiceMoveEvent e69 = (GuildVoiceMoveEvent)event; + s = db.prepareStatement("INSERT INTO guildVoiceMoveEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e69.getGuild().getIdLong()); + s.setLong(3, e69.getMember().getUser().getIdLong()); + s.setLong(4, e69.getChannelLeft().getIdLong()); + s.setLong(5, e69.getChannelJoined().getIdLong()); + break; + + case "UnavailableGuildJoinedEvent": + UnavailableGuildJoinedEvent e70 = (UnavailableGuildJoinedEvent)event; + s = db.prepareStatement("INSERT INTO unavailableGuildJoinedEvent VALUES (?,?)"); + s.setLong(2, e70.getGuildIdLong()); + break; + + + ////////// GenericTextChannelEvent ////////// + case "TextChannelCreateEvent": + TextChannelCreateEvent e71 = (TextChannelCreateEvent)event; + s = db.prepareStatement("INSERT INTO textChannelCreateEvent VALUES (?,?,?)"); + s.setLong(2, e71.getGuild().getIdLong()); + s.setLong(3, e71.getChannel().getIdLong()); + break; + case "TextChannelDeleteEvent": + TextChannelDeleteEvent e72 = (TextChannelDeleteEvent)event; + s = db.prepareStatement("INSERT INTO textChannelDeleteEvent VALUES (?,?,?)"); + s.setLong(2, e72.getGuild().getIdLong()); + s.setLong(3, e72.getChannel().getIdLong()); + break; + case "TextChannelUpdatePermissionsEvent": + TextChannelUpdatePermissionsEvent e73 = (TextChannelUpdatePermissionsEvent)event; + addPermissionHolders(geid, e73.getChangedPermissionHolders(), db); + s = db.prepareStatement("INSERT INTO textChannelUpdatePermissionsEvent VALUES (?,?,?)"); + s.setLong(2, e73.getGuild().getIdLong()); + s.setLong(3, e73.getChannel().getIdLong()); + break; + case "TextChannelUpdateNameEvent": + TextChannelUpdateNameEvent e74 = (TextChannelUpdateNameEvent)event; + s = db.prepareStatement("INSERT INTO textChannelUpdateNameEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e74.getGuild().getIdLong()); + s.setLong(3, e74.getChannel().getIdLong()); + s.setString(4, e74.getOldName()); + s.setString(5, e74.getNewName()); + break; + case "TextChannelUpdateNSFWEvent": + TextChannelUpdateNSFWEvent e75 = (TextChannelUpdateNSFWEvent)event; + s = db.prepareStatement("INSERT INTO textChannelUpdateNSFWEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e75.getGuild().getIdLong()); + s.setLong(3, e75.getChannel().getIdLong()); + s.setBoolean(4, e75.getOldNSFW()); + break; + case "TextChannelUpdateParentEvent": + TextChannelUpdateParentEvent e76 = (TextChannelUpdateParentEvent)event; + s = db.prepareStatement("INSERT INTO textChannelUpdateParentEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e76.getGuild().getIdLong()); + s.setLong(3, e76.getChannel().getIdLong()); + s.setLong(4, e76.getOldParent().getIdLong()); + s.setLong(5, e76.getNewParent().getIdLong()); + break; + case "TextChannelUpdatePositionEvent": + TextChannelUpdatePositionEvent e77 = (TextChannelUpdatePositionEvent)event; + s = db.prepareStatement("INSERT INTO textChannelUpdatePositionEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e77.getGuild().getIdLong()); + s.setLong(3, e77.getChannel().getIdLong()); + s.setInt(4, e77.getOldPosition()); + s.setInt(5, e77.getNewPosition()); + break; + case "TextChannelUpdateTopicEvent": + TextChannelUpdateTopicEvent e78 = (TextChannelUpdateTopicEvent)event; + s = db.prepareStatement("INSERT INTO textChannelUpdateTopicEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e78.getGuild().getIdLong()); + s.setLong(3, e78.getChannel().getIdLong()); + s.setString(4, e78.getOldTopic()); + s.setString(5, e78.getNewTopic()); + break; + + + ////////// GenericTextChannelEvent ////////// + case "VoiceChannelCreateEvent": + VoiceChannelCreateEvent e79 = (VoiceChannelCreateEvent)event; + s = db.prepareStatement("INSERT INTO voiceChannelCreateEvent VALUES (?,?,?)"); + s.setLong(2, e79.getGuild().getIdLong()); + s.setLong(3, e79.getChannel().getIdLong()); + break; + case "VoiceChannelDeleteEvent": + VoiceChannelDeleteEvent e80 = (VoiceChannelDeleteEvent)event; + s = db.prepareStatement("INSERT INTO voiceChannelDeleteEvent VALUES (?,?,?)"); + s.setLong(2, e80.getGuild().getIdLong()); + s.setLong(3, e80.getChannel().getIdLong()); + break; + case "VoiceChannelUpdatePermissionsEvent": + VoiceChannelUpdatePermissionsEvent e81 = (VoiceChannelUpdatePermissionsEvent)event; + addPermissionHolders(geid, e81.getChangedPermissionHolders(), db); + s = db.prepareStatement("INSERT INTO voiceChannelUpdatePermissionsEvent VALUES (?,?,?)"); + s.setLong(2, e81.getGuild().getIdLong()); + s.setLong(3, e81.getChannel().getIdLong()); + break; + case "VoiceChannelUpdateBitrateEvent": + VoiceChannelUpdateBitrateEvent e82 = (VoiceChannelUpdateBitrateEvent)event; + s = db.prepareStatement("INSERT INTO voiceChannelUpdateBitrateEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e82.getGuild().getIdLong()); + s.setLong(3, e82.getChannel().getIdLong()); + s.setInt(4, e82.getOldBitrate()); + s.setInt(5, e82.getNewBitrate()); + break; + case "VoiceChannelUpdateNameEvent": + VoiceChannelUpdateNameEvent e83 = (VoiceChannelUpdateNameEvent)event; + s = db.prepareStatement("INSERT INTO voiceChannelUpdateNameEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e83.getGuild().getIdLong()); + s.setLong(3, e83.getChannel().getIdLong()); + s.setString(4, e83.getOldName()); + s.setString(5, e83.getNewName()); + break; + case "VoiceChannelUpdateParentEvent": + VoiceChannelUpdateParentEvent e84 = (VoiceChannelUpdateParentEvent)event; + s = db.prepareStatement("INSERT INTO voiceChannelUpdateParentEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e84.getGuild().getIdLong()); + s.setLong(3, e84.getChannel().getIdLong()); + s.setLong(4, e84.getOldParent().getIdLong()); + s.setLong(5, e84.getNewParent().getIdLong()); + break; + case "VoiceChannelUpdatePositionEvent": + VoiceChannelUpdatePositionEvent e85 = (VoiceChannelUpdatePositionEvent)event; + s = db.prepareStatement("INSERT INTO voiceChannelUpdatePositionEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e85.getGuild().getIdLong()); + s.setLong(3, e85.getChannel().getIdLong()); + s.setInt(4, e85.getOldPosition()); + s.setInt(5, e85.getNewPosition()); + break; + case "VoiceChannelUpdateUserLimitEvent": + VoiceChannelUpdateUserLimitEvent e86 = (VoiceChannelUpdateUserLimitEvent)event; + s = db.prepareStatement("INSERT INTO voiceChannelUpdateUserLimitEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e86.getGuild().getIdLong()); + s.setLong(3, e86.getChannel().getIdLong()); + s.setInt(4, e86.getOldUserLimit()); + s.setInt(5, e86.getNewUserLimit()); + break; + + + ////////// GenericCategoryEvent ////////// + case "CategoryCreateEvent": + CategoryCreateEvent e87 = (CategoryCreateEvent)event; + s = db.prepareStatement("INSERT INTO categoryCreateEvent VALUES (?,?,?)"); + s.setLong(2, e87.getGuild().getIdLong()); + s.setLong(3, e87.getCategory().getIdLong()); + break; + case "CategoryDeleteEvent": + CategoryDeleteEvent e88 = (CategoryDeleteEvent)event; + s = db.prepareStatement("INSERT INTO categoryDeleteEvent VALUES (?,?,?)"); + s.setLong(2, e88.getGuild().getIdLong()); + s.setLong(3, e88.getCategory().getIdLong()); + break; + case "CategoryUpdatePermissionsEvent": + CategoryUpdatePermissionsEvent e89 = (CategoryUpdatePermissionsEvent)event; + addPermissionHolders(geid, e89.getChangedPermissionHolders(), db); + s = db.prepareStatement("INSERT INTO categoryUpdatePermissionsEvent VALUES (?,?,?)"); + s.setLong(2, e89.getGuild().getIdLong()); + s.setLong(3, e89.getCategory().getIdLong()); + break; + case "CategoryUpdateNameEvent": + CategoryUpdateNameEvent e90 = (CategoryUpdateNameEvent)event; + s = db.prepareStatement("INSERT INTO categoryUpdateNameEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e90.getGuild().getIdLong()); + s.setLong(3, e90.getCategory().getIdLong()); + s.setString(4, e90.getOldName()); + s.setString(5, e90.getNewName()); + break; + case "CategoryUpdatePositionEvent": + CategoryUpdatePositionEvent e91 = (CategoryUpdatePositionEvent)event; + s = db.prepareStatement("INSERT INTO categoryUpdatePositionEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e91.getGuild().getIdLong()); + s.setLong(3, e91.getCategory().getIdLong()); + s.setInt(4, e91.getOldPosition()); + s.setInt(5, e91.getNewPosition()); + break; + + + ////////// GenericPrivateChannelEvent ////////// + case "PrivateChannelCreateEvent": + PrivateChannelCreateEvent e92 = (PrivateChannelCreateEvent)event; + s = db.prepareStatement("INSERT INTO privateChannelCreateEvent VALUES (?,?,?)"); + s.setLong(2, e92.getUser().getIdLong()); + s.setLong(3, e92.getChannel().getIdLong()); + break; + case "PrivateChannelDeleteEvent": + PrivateChannelDeleteEvent e93 = (PrivateChannelDeleteEvent)event; + s = db.prepareStatement("INSERT INTO privateChannelDeleteEvent VALUES (?,?,?)"); + s.setLong(2, e93.getUser().getIdLong()); + s.setLong(3, e93.getChannel().getIdLong()); + break; + + + ////////// GenericRoleEvent ////////// + case "RoleCreateEvent": + RoleCreateEvent e94 = (RoleCreateEvent)event; + s = db.prepareStatement("INSERT INTO roleCreateEvent VALUES (?,?,?)"); + s.setLong(2, e94.getGuild().getIdLong()); + s.setLong(3, e94.getRole().getIdLong()); + break; + case "RoleDeleteEvent": + RoleDeleteEvent e95 = (RoleDeleteEvent)event; + s = db.prepareStatement("INSERT INTO roleDeleteEvent VALUES (?,?,?)"); + s.setLong(2, e95.getGuild().getIdLong()); + s.setLong(3, e95.getRole().getIdLong()); + break; + case "RoleUpdateColorEvent": + RoleUpdateColorEvent e97 = (RoleUpdateColorEvent)event; + s = db.prepareStatement("INSERT INTO RoleUpdateColorEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e97.getGuild().getIdLong()); + s.setLong(3, e97.getRole().getIdLong()); + s.setInt(4, e97.getOldColorRaw()); + s.setInt(5, e97.getNewColorRaw()); + break; + case "RoleUpdateHoistedEvent": + RoleUpdateHoistedEvent e98 = (RoleUpdateHoistedEvent)event; + s = db.prepareStatement("INSERT INTO RoleUpdateHoistedEvent VALUES (?,?,?,?)"); + s.setLong(2, e98.getGuild().getIdLong()); + s.setLong(3, e98.getRole().getIdLong()); + s.setBoolean(4, e98.wasHoisted()); + break; + case "RoleUpdateMentionableEvent": + RoleUpdateMentionableEvent e101 = (RoleUpdateMentionableEvent)event; + s = db.prepareStatement("INSERT INTO RoleUpdateMentionableEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e101.getGuild().getIdLong()); + s.setLong(3, e101.getRole().getIdLong()); + s.setBoolean(4, e101.wasMentionable()); + break; + case "RoleUpdateNameEvent": + RoleUpdateNameEvent e99 = (RoleUpdateNameEvent)event; + s = db.prepareStatement("INSERT INTO roleUpdateNameEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e99.getGuild().getIdLong()); + s.setLong(3, e99.getRole().getIdLong()); + s.setString(4, e99.getOldName()); + s.setString(5, e99.getNewName()); + break; + case "RoleUpdatePermissionsEvent": + RoleUpdatePermissionsEvent e96 = (RoleUpdatePermissionsEvent)event; + s = db.prepareStatement("INSERT INTO roleUpdatePermissionsEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e96.getGuild().getIdLong()); + s.setLong(3, e96.getRole().getIdLong()); + s.setString(4, e96.getOldPermissions().stream().map(perm -> perm.name()).collect(Collectors.joining(","))); + s.setString(5, e96.getNewPermissions().stream().map(perm -> perm.name()).collect(Collectors.joining(","))); + break; + case "RoleUpdatePositionEvent": + RoleUpdatePositionEvent e100 = (RoleUpdatePositionEvent)event; + s = db.prepareStatement("INSERT INTO roleUpdatePositionEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e100.getGuild().getIdLong()); + s.setLong(3, e100.getRole().getIdLong()); + s.setInt(4, e100.getOldPosition()); + s.setInt(5, e100.getNewPosition()); + break; + + + ////////// GenericEmote ////////// + case "EmoteAddedEvent": + EmoteAddedEvent e102 = (EmoteAddedEvent)event; + s = db.prepareStatement("INSERT INTO emoteAddedEvent VALUES (?,?,?,?)"); + s.setLong(2, e102.getGuild().getIdLong()); + s.setLong(3, e102.getEmote().getIdLong()); + s.setBoolean(4, e102.isManaged()); + break; + case "EmoteRemovedEvent": + EmoteRemovedEvent e103 = (EmoteRemovedEvent)event; + s = db.prepareStatement("INSERT INTO emoteRemovedEvent VALUES (?,?,?,?)"); + s.setLong(2, e103.getGuild().getIdLong()); + s.setLong(3, e103.getEmote().getIdLong()); + s.setBoolean(4, e103.isManaged()); + break; + case "EmoteUpdateNameEvent": + EmoteUpdateNameEvent e104 = (EmoteUpdateNameEvent)event; + s = db.prepareStatement("INSERT INTO emoteUpdateNameEvent VALUES (?,?,?,?,?,?)"); + s.setLong(2, e104.getGuild().getIdLong()); + s.setLong(3, e104.getEmote().getIdLong()); + s.setBoolean(4, e104.isManaged()); + s.setString(5, e104.getOldName()); + s.setString(6, e104.getNewName()); + break; + case "EmoteUpdateRolesEvent": + EmoteUpdateRolesEvent e105 = (EmoteUpdateRolesEvent)event; + s = db.prepareStatement("INSERT INTO emoteUpdateRolesEvent VALUES (?,?,?,?,?,?)"); + s.setLong(2, e105.getGuild().getIdLong()); + s.setLong(3, e105.getEmote().getIdLong()); + s.setBoolean(4, e105.isManaged()); + s.setString(5, e105.getOldRoles().stream().map(r -> r.getId()).collect(Collectors.joining(","))); + s.setString(6, e105.getNewRoles().stream().map(r -> r.getId()).collect(Collectors.joining(","))); + break; + + + + + + + + + case "HttpRequestEvent": + 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()); } s.setLong(1, geid);//Le GEID s.executeUpdate(); } catch (SQLException e1) { System.err.println("Mysql pas content ......"); e1.printStackTrace(); + } catch(IllegalStateException e) { + System.err.println("Je continue quand même a récupérer les évents"); + e.printStackTrace(); + } catch(NumberFormatException e) { + System.err.println("Y a un truc qui a éssayé de rentrer dans la BDD mais qui a pas réussi"); + e.printStackTrace(); + } catch(Exception e) { + System.err.println("Snif, je suis mal codée, c'est parce que vous m'aimez pas, hein ?"); + e.printStackTrace(); } } - - public void stop() { - stop = true; - } - } @@ -265,14 +1044,197 @@ public class EcouteurDEvents implements EventListener{ s.executeUpdate(); } } + public static void addRoles(long geid,List roles, Connection db) throws SQLException { + for(Role r : roles) { + PreparedStatement s = db.prepareStatement("INSERT INTO roles VALUES (NULL,?,?)"); + s.setLong(1, geid); + s.setLong(2, r.getIdLong()); + s.executeUpdate(); + } + } + public static void addEmbedMessage(long geid,List messages, Connection db) throws SQLException { + for(MessageEmbed m : messages) { + PreparedStatement s = db.prepareStatement("INSERT INTO embedMessage VALUES (NULL,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",Statement.RETURN_GENERATED_KEYS); + s.setLong(1, geid); + if(m.getAuthor()==null) { + s.setObject(2, null); + s.setObject(3, null); + s.setObject(4, null); + s.setObject(5, null); + }else { + s.setString(2, m.getAuthor().getName()); + s.setString(3, m.getAuthor().getIconUrl()); + s.setString(4, m.getAuthor().getProxyIconUrl()); + s.setString(5, m.getAuthor().getUrl()); + } + s.setInt(6, m.getColorRaw()); + s.setString(7, m.getDescription()); + if(m.getFooter()==null) { + s.setObject(8, null); + s.setObject(9, null); + s.setObject(10, null); + }else { + s.setString(8, m.getFooter().getIconUrl()); + s.setString(9, m.getFooter().getProxyIconUrl()); + s.setString(10, m.getFooter().getText()); + } + if(m.getImage()==null) { + s.setObject(11, null); + s.setObject(12, null); + }else { + s.setString(11, m.getImage().getUrl()); + s.setString(12, m.getImage().getProxyUrl()); + } + if(m.getSiteProvider()==null) { + s.setObject(13, null); + s.setObject(14, null); + }else { + s.setString(13, m.getSiteProvider().getName()); + s.setString(14, m.getSiteProvider().getUrl()); + } + s.setString(15, (m.getThumbnail()==null)?null:m.getThumbnail().getUrl()); + s.setTimestamp(16,(m.getTimestamp()==null)?null:new Timestamp( m.getTimestamp().toEpochSecond())); + s.setString(17, m.getTitle()); + s.setString(18, m.getUrl()); + s.setString(19, m.getType().name()); + s.setString(20, (m.getVideoInfo()==null)?null:m.getVideoInfo().getUrl()); + + s.executeUpdate(); + + ResultSet rs = s.getGeneratedKeys(); + rs.next(); + int embedID = rs.getInt(1); + + for(MessageEmbed.Field f : m.getFields()) { + PreparedStatement ss = db.prepareStatement("INSERT INTO embedMessageField VALUES (NULL,?,?,?,?)"); + ss.setInt(1, embedID); + ss.setString(2, f.getName()); + ss.setString(3, f.getValue()); + ss.setBoolean(4, f.isInline()); + + ss.executeUpdate(); + } + } + } + public static int addMessage(Message m, Connection db) throws SQLException { + PreparedStatement s = db.prepareStatement("INSERT INTO message VALUES (NULL,?,?,?,?,?,?,?,?,?,?)",Statement.RETURN_GENERATED_KEYS); + s.setLong(1, m.getIdLong()); + s.setLong(2, m.getAuthor().getIdLong()); + s.setLong(3, m.getChannel().getIdLong()); + s.setString(4, m.getContentRaw()); + s.setTimestamp(5, (m.isEdited())?new Timestamp(m.getEditedTime().toEpochSecond()):null); + if(m.getGroup()==null)s.setObject(6, null);else s.setLong(6, m.getGroup().getIdLong()); + if(m.getGuild()==null)s.setObject(7, null);else s.setLong(7, m.getGuild().getIdLong()); + s.setString(8, m.getJumpUrl()); + s.setBoolean(9, m.isPinned()); + s.setBoolean(10, m.isTTS()); + s.executeUpdate(); + + ResultSet rs = s.getGeneratedKeys(); + rs.next(); + int mID = rs.getInt(1); + + return mID; + } + public static int addMessageReaction(MessageReaction r, Connection db) throws SQLException { + PreparedStatement s = db.prepareStatement("INSERT INTO messageReaction VALUES (NULL,?,?,?,?)",Statement.RETURN_GENERATED_KEYS); + s.setInt(1, r.getCount()); + s.setLong(2, r.getMessageIdLong()); + s.setString(3, r.getReactionEmote().getName()); + s.setLong(4, r.getReactionEmote().getIdLong()); + s.executeUpdate(); + + ResultSet rs = s.getGeneratedKeys(); + rs.next(); + int rID = rs.getInt(1); + + return rID; + } + public static long addSelfUser(SelfUser user, Connection db) throws SQLException { + long hash = hash(user.getAllowedFileSize()+user.getEmail()+user.getPhoneNumber()+user.isNitro()+user.isVerified()+user.isMobile()+user.isMfaEnabled()); + PreparedStatement s = db.prepareStatement("INSERT INTO selfUser VALUES (?,?,?,?,?)"); + s.setLong(1, hash); + s.setLong(2, user.getAllowedFileSize()); + s.setString(3, user.getEmail()); + s.setString(4, user.getPhoneNumber()); + List tags = new ArrayList<>(); + if(user.isNitro())tags.add("NITRO"); + if(user.isVerified())tags.add("VERIFIED"); + if(user.isMobile())tags.add("MOBILE"); + if(user.isMfaEnabled())tags.add("MFA_ENABLED"); + s.setString(5, String.join(",", tags)); + try { + s.executeUpdate(); + }catch(SQLIntegrityConstraintViolationException err) { + return hash;//La clé a déjà été enregistrée + } + return hash; + } + public static Long addGame(Game g, Connection db) throws SQLException { + if(g==null)return null; + String h = ""; + PreparedStatement s = db.prepareStatement("INSERT INTO game VALUES (?,?,?,?,?,?,?,?,?,?,?,?,UNHEX(?),?,?,?,?)"); + s.setString(2, g.getType().name());h+=g.getType().name(); + s.setString(3, g.getName());h+=g.getName(); + s.setString(4, g.getUrl());h+=g.getUrl(); + if(g.isRich()) { + s.setLong(5, g.asRichPresence().getApplicationIdLong());h+=g.asRichPresence().getApplicationIdLong(); + s.setString(6, g.asRichPresence().getDetails());h+=g.asRichPresence().getDetails(); + s.setString(7, g.asRichPresence().getFlagSet().stream().map(aflag -> aflag.name()).collect(Collectors.joining(",")));h+=g.asRichPresence().getFlags(); + s.setString(8, (g.asRichPresence().getLargeImage()!=null)?g.asRichPresence().getLargeImage().getUrl():null);h+=(g.asRichPresence().getLargeImage()!=null)?g.asRichPresence().getLargeImage().getUrl():""; + if(g.asRichPresence().getParty() != null) { + s.setString(9,g.asRichPresence().getParty().getId());h+= g.asRichPresence().getParty().getId(); + s.setInt(10, g.asRichPresence().getParty().getMax());h+=g.asRichPresence().getParty().getMax(); + s.setInt(11, g.asRichPresence().getParty().getSize());h+=g.asRichPresence().getParty().getSize(); + }else { + s.setObject(9, null); + s.setObject(10, null); + s.setObject(11, null); + } + s.setString(12, (g.asRichPresence().getSmallImage()!=null)?g.asRichPresence().getSmallImage().getUrl():null);h+=(g.asRichPresence().getSmallImage()!=null)?g.asRichPresence().getSmallImage().getUrl():""; + s.setObject(13, (g.asRichPresence().getSessionId()==null)?g.asRichPresence().getSessionId():null);h+=(g.asRichPresence().getSessionId()==null)?g.asRichPresence().getSessionId():""; + s.setObject(14, (g.asRichPresence().getSyncId()==null)?g.asRichPresence().getSyncId():null);h+=(g.asRichPresence().getSyncId()==null)?g.asRichPresence().getSyncId():""; + s.setString(15, g.asRichPresence().getState());h+=g.asRichPresence().getState(); + s.setTimestamp(16, (g.asRichPresence().getTimestamps()!=null)?new Timestamp(g.asRichPresence().getTimestamps().getStart()):null);h+=(g.asRichPresence().getTimestamps()!=null)?g.asRichPresence().getTimestamps().getStart():""; + s.setTimestamp(17, (g.asRichPresence().getTimestamps()!=null)?new Timestamp(g.asRichPresence().getTimestamps().getEnd()):null);h+=(g.asRichPresence().getTimestamps()!=null)?g.asRichPresence().getTimestamps().getEnd():""; + }else { + for (int i = 5;i<=17;i++) + s.setObject(i, null); + } + + long hash = hash(h); + s.setLong(1, hash); + try { + s.executeUpdate(); + }catch(SQLIntegrityConstraintViolationException err) { + return hash;//La clé a déjà été enregistrée + } + return hash; + } + public static long hash(String string) { + long h = 1125899906842597L; // prime + int len = string.length(); + for (int i = 0; i < len; i++) { + h = 31*h + string.charAt(i); + } + return h; + } + + @SafeVarargs + public static T c(T... p) { + for(T t : p) + if(t != null) + return t; + return null; + } public static class PendingEventStore { Event e; - Date eTime; + Timestamp eTime; - public PendingEventStore(Event e, Date date) { + public PendingEventStore(Event e, Timestamp date) { this.e = e; this.eTime = date; } @@ -281,7 +1243,7 @@ public class EcouteurDEvents implements EventListener{ return e; } - public Date geteTime() { + public Timestamp geteTime() { return eTime; } diff --git a/src/main/java/com/bernard/juliabot/Julia.java b/src/main/java/com/bernard/juliabot/Julia.java index af07212..1b2c351 100644 --- a/src/main/java/com/bernard/juliabot/Julia.java +++ b/src/main/java/com/bernard/juliabot/Julia.java @@ -1,113 +1,136 @@ package com.bernard.juliabot; -import java.io.File; -import java.io.IOException; -import java.lang.reflect.Constructor; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; -import java.sql.Connection; -import java.sql.DriverManager; -import java.sql.PreparedStatement; -import java.sql.ResultSet; -import java.sql.SQLException; -import java.sql.Statement; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Map; -import java.util.Properties; -import java.util.Set; +import java.io.*; +import java.lang.reflect.*; +import java.sql.*; +import java.util.*; import java.util.jar.JarEntry; import java.util.jar.JarFile; +import java.util.stream.Collectors; import com.bernard.juliabot.JuliaAddon.JarWithMultipleAddonsException; import com.bernard.juliabot.JuliaAddon.JuliaClassLoader; -import com.bernard.juliabot.api.Command; -import com.bernard.juliabot.api.CommandCall; -import com.bernard.juliabot.api.Discord; +import com.bernard.juliabot.api.*; +import com.thedeanda.lorem.LoremIpsum; -import net.dv8tion.jda.core.AccountType; -import net.dv8tion.jda.core.JDA; -import net.dv8tion.jda.core.JDABuilder; +import net.dv8tion.jda.core.*; import net.dv8tion.jda.core.events.Event; public class Julia { public static final String juliaddonsFolder = "/home/julia/juliaddons/"; + public static final String sysinPipe = "/home/julia/entree"; + private static final String token = ""; static Julia theJulia; - JDA jda; + public JDA jda; Map avalivableAddons;//pkg+version->addon Map laboratoriesIdentifieurs;//Store channels IDs ... - Map laboratoires; + public Map laboratoires; Map fileTrack;// + public EcouteurDEvents lecouteur; + ReadLoop sysinator; + Connection eventDatabase; Connection juliaDatabase; public Julia() { + avalivableAddons = new HashMap<>(); laboratoriesIdentifieurs = new HashMap<>(); laboratoires = new HashMap<>(); fileTrack = new HashMap<>(); - + } + + public synchronized void startup() { //Set up mysql cnnections (events & data) Properties connectionProps = new Properties(); - connectionProps.put("user", "julia"); - connectionProps.put("password", "juliabestbotever"); - connectionProps.put("serverTimezone", "UTC"); - connectionProps.put("verifyServerCertificate", "false"); - connectionProps.put("useSSL", "true"); - connectionProps.put("requireSSL", "true"); - try { - eventDatabase = DriverManager.getConnection("jdbc:mysql://localhost:3306/juliaEvents", connectionProps); - juliaDatabase = DriverManager.getConnection("jdbc:mysql://localhost:3306/julia", connectionProps); - } catch (SQLException e) { + connectionProps.put("user", "julia"); + connectionProps.put("password", "juliabestbotever"); + connectionProps.put("serverTimezone", "UTC"); + connectionProps.put("verifyServerCertificate", "false"); + 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) { 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(); return; } - - //XXX sSet up JDA and Bot - - try { - jda = new JDABuilder(AccountType.BOT).setToken(token).buildBlocking(); + + System.out.println("La BDD est charg��e" + eventDatabase+","+juliaDatabase); + + + // 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(); return; } - + + jda.getGuildById(222947179017404416L).getTextChannelById(460935684669046784L).sendMessage(LoremIpsum.getInstance().getWords(10, 15)).complete(); //Launch update to see every addon in juliaddon/ update();//Va remplir la map avalivableAddons - //Load addons in # and in $ (récupere ce qu'il faut dans la BDD) + + //D��marrage du sysin + sysinator = new ReadLoop(); + Thread sysinThread = new Thread(sysinator, "sysin-reader"); + sysinThread.start(); + + System.out.println("Sont disponibles :"+avalivableAddons); + //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) + Set toLoad = new HashSet<>(); try { Statement statement = juliaDatabase.createStatement(); ResultSet result = statement.executeQuery("SELECT * FROM loadedJuliaddons"); - do { + while(result.next()) { char laboratory = result.getString("laboratory").charAt(0); String pkg = result.getString("pkg"); String version = result.getString("version"); - if(!laboratoires.containsKey(laboratory)) - laboratoires.put(laboratory, new Laboratory(laboratory)); - Laboratory labo = laboratoires.get(laboratory); - labo.loadAddon(pkg, version, false);//Pas besoin d'update, il viens d'etre fait - }while(result.next()); + toLoad.add(laboratory+pkg+":"+version); + } } catch (SQLException e) { System.err.println("Impossible de charger les plugins, vous aurez tout a faire a la main !"); e.printStackTrace(); } + 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(); + } + + for(String l : toLoad) { + if(!laboratoires.containsKey(l.charAt(0))) + laboratoires.put(l.charAt(0), new Laboratory(l.charAt(0))); + Laboratory labo = laboratoires.get(l.charAt(0)); + labo.loadAddon(l.substring(1, l.lastIndexOf(":")), l.substring(l.lastIndexOf(":")+1), false);//Pas besoin d'update, il viens d'etre fait + + } } @@ -115,8 +138,8 @@ public class Julia { Map avalivableAddons = new HashMap<>(); File juliaddonFolder = new File(juliaddonsFolder); for(File f : juliaddonFolder.listFiles((parent,name)->name.toLowerCase().endsWith(".jar"))){ - if(fileTrack.get(f.getName()) == f.lastModified()) - continue;//Le fichier n'a pas bougé, pas besoin de le relire + if(fileTrack.containsKey(f.getName()) && fileTrack.get(f.getName()) == f.lastModified()) + continue;//Le fichier n'a pas boug��, pas besoin de le relire fileTrack.put(f.getName(), f.lastModified()); try { JarFile jar = new JarFile(f); @@ -124,7 +147,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�� 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(); @@ -133,15 +156,17 @@ 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�� 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'eteint tout, c'est mieux"); + System.err.println("TOUT EST CASS�� ALERTE ROUGE !"); + System.err.println("C'est problematique, j'��teint tout, c'est mieux"); System.exit(31415926); } } + }catch(IllegalStateException e) { + System.err.println(e.getMessage()); } } catch (IOException e) { System.err.println("Impossible de lire le fichier jar "+f.getName()); @@ -151,18 +176,49 @@ public class Julia { this.avalivableAddons = avalivableAddons; } + public class ReadLoop implements Runnable{ + + boolean running = false; + + @Override + public void run() { + + running = true; + try { + Scanner sc = new Scanner(new File(sysinPipe)); + while(running) { + String request = sc.nextLine(); + + System.out.println("Je suis cens�� avoir lu la commande "+request); + //TODO r��agir ... + + + + } + + sc.close(); + } catch (FileNotFoundException e) { + System.err.println("Erreur de lecture du sysin, je deviens sourd"); + e.printStackTrace(); + running=false; + } + } + + } + public class Laboratory{ char laboratory; - Map loadedAddons;// - Map loadedCommands; - Map,Object> callerObjects; - Map aliases; - Map,Set> loadedEvents; + 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 clazzTrack;// + public Laboratory(char laboratory) { this.laboratory = laboratory; loadedAddons = new HashMap<>(); @@ -170,6 +226,7 @@ public class Julia { aliases = new HashMap<>(); loadedEvents = new HashMap<>(); clazzTrack = new HashMap<>(); + callerObjects = new HashMap<>(); } public JuliaClassLoader findClassLoader(String className) { @@ -180,6 +237,7 @@ public class Julia { unloadAddon(pkg); loadAddon(pkg, version); } + public void loadAddon(String pkg,String version) { this.loadAddon(pkg, version, true); } @@ -187,9 +245,9 @@ 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 juliaddons (laboratory,pkg,version) VALUES (?,?,?)"); + PreparedStatement s = juliaDatabase.prepareStatement("INSERT INTO loadedJuliaddons (ID,laboratory,pkg,version) VALUES (NULL,?,?,?)"); s.setString(1, Character.toString(laboratory)); s.setString(2, pkg); s.setString(3, version); @@ -210,13 +268,13 @@ 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 ..."); @@ -229,34 +287,46 @@ public class Julia { } public synchronized void registerCommand(Method m,Command c) { - if(loadedCommands.containsKey(c.name())) - throw new IllegalStateException("Une commade "+c.name()+" a déjà été enregistrée !"); + if(!loadedCommands.containsKey(c.name())) + loadedCommands.put(c.name(), new CommandeSurchargee(c)); + //Verify that commands asks for good argument - Class[] parameters = m.getParameterTypes(); - if(parameters.length > 1) - throw new IllegalArgumentException("La méthode d'une commande ne peux prendre au maximum qu'un argument (de type CommandCall), la méthode fautive étant "+m.toGenericString()); - if(parameters.length == 1 && parameters[0] == CommandCall.class) - throw new IllegalArgumentException("La méthode d'une commande, si elle possede un argument, ce dernier doit tre de type CommandCall, la méthode fautive étant "+m.toGenericString()); + 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"); + + try { + m.setAccessible(true); + }catch(SecurityException e) { + throw new IllegalArgumentException("Impossible de me donner le droit d'��xecuter "+m.toGenericString()); + } + // Argument OK //Register aliases - for(String alias:c.aliases()) { - if(aliases.containsKey(alias)) - System.err.println("Faut remplacer l'alias "+alias+", plus de deux addons l'utilisent"); - aliases.put(alias, c.name()); - } - //Création de l'objet si ca n'a pas été fait + // 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())); + + + + //Cr��ation de l'objet si ca n'a pas ��t�� fait checkObject(m.getDeclaringClass()); - loadedCommands.put(c.name(), m); + + //Enregistre la nouvelle surcharge + loadedCommands.get(c.name()).surcharger(Arrays.stream(m.getParameterTypes()).collect(Collectors.toSet()), m); + } @SuppressWarnings("unchecked")//It is, in reallity checked 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()); - 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 catcheurs d'events ne doivent avoir qu'un seul param��tre, extends Event, la m��thde 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 if(!loadedEvents.containsKey(parameters[0])) loadedEvents.put((Class) parameters[0], new HashSet<>()); checkObject(m.getDeclaringClass()); @@ -265,7 +335,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 @@ -273,10 +343,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); } @@ -294,6 +364,14 @@ public class Julia { case "java.lang.Character": params[i] = this.laboratory; break; + case "java.sql.Connection": + params[i] = Julia.this.juliaDatabase; + break; + case "net.dv8tion.jda.core.JDA": + params[i] = Julia.this.jda; + break; + //TODO completer les param��tres + default: continue constLoop; } @@ -303,21 +381,112 @@ public class Julia { //Tant pis, constructeur suivant continue constLoop; } - if(o != null)break;//Sortir de la boucle, on a notre juli objet + 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); } } public void trigger(Event event) { - // TODO Auto-generated method stub + Class eventClass = event.getClass(); + Set toCall = loadedEvents.get(eventClass); + for(Method m : toCall) { + Object callable = callerObjects.get(m.getDeclaringClass()); + 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()); + 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()); + 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()); + e.printStackTrace(); + throw new IllegalStateException(e); + } + } } + public CommandCalled executeCommand(String name, CCommande content) { + + String cname = name; + + if(aliases.containsKey(name)) + cname = aliases.get(name); + if(!loadedCommands.containsKey(cname)) + throw new IllegalArgumentException("Je ne connais ni la commande, ni l'alias "+cname); + + + 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()); + final Object[] parameters = new Object[m.getParameterCount()]; + Arrays.fill(parameters, content); + final Object caller = callerObjects.get(m.getDeclaringClass()); + + final CommandCalled called = new CommandCalled(m, content, name, cname, caller); + + + Thread t = new Thread(() -> { + + try { + + m.invoke(caller, parameters); + + } catch (IllegalAccessException e) { + System.err.println("Probl��me d'acc��s �� la m��thode "+m.toGenericString()+" ... c'est emb��tant"); + e.printStackTrace(); + called.setExitValue(e.getCause()); + } catch (IllegalArgumentException e) { + System.err.println("��trange, je pensais avoir check les arguments"); + e.printStackTrace(); + called.setExitValue(e.getCause()); + } catch (InvocationTargetException e) { + //Lui a plant�� + called.setExitValue(e.getCause()); + } + + called.ended(); + + }, "commande-"+cname+".aka."+name+"-"+System.nanoTime()); + + called.setThread(t); + + t.start(); + + return called; + } + + + public Map getLoadedAddons() { + return loadedAddons; + } + + public Map getLoadedCommands() { + return loadedCommands; + } + + public Map getAliases() { + return aliases; + } + + public Map, Set> getLoadedEvents() { + return loadedEvents; + } + + public char getL() { + return laboratory; + } + + } @@ -327,6 +496,7 @@ public class Julia { public static void main(String[] args) { theJulia = new Julia(); + theJulia.startup(); } public static Julia theJulia() { diff --git a/src/main/java/com/bernard/juliabot/JuliaAddon.java b/src/main/java/com/bernard/juliabot/JuliaAddon.java index 41c2345..ee3a14a 100644 --- a/src/main/java/com/bernard/juliabot/JuliaAddon.java +++ b/src/main/java/com/bernard/juliabot/JuliaAddon.java @@ -22,8 +22,8 @@ import com.bernard.juliabot.api.JuLIAddon; public class JuliaAddon { - private static final Pattern pkgFromClassName = Pattern.compile("^(\\w(\\.\\w){2,})\\.\\w(\\$\\w)*$"); - private static final Pattern jarNameParser = Pattern.compile("^([^_])_([^_])(_(.*))?.jar$"); + private static final Pattern pkgFromClassName = Pattern.compile("^(\\w+(\\.\\w+){2,})\\.\\w+(\\$\\w+)*$"); + private static final Pattern jarNameParser = Pattern.compile("^([^_]+)_([^_]+)(_(.+))?.jar$"); String pkg; @@ -51,27 +51,30 @@ public class JuliaAddon { //Parsing du nom du fichier Matcher jarMatcher = jarNameParser.matcher(jar.getName()); - jarMatcher.matches(); + if(!jarMatcher.matches()) + throw new IllegalStateException("Le fichier n'a pas un nom valide, je ne peux pas récupérer la version du juliaddon : "+jar.getName().split("/")[jar.getName().split("/").length-1]); //String jarAddonName = jarMatcher.group(1); String jarVersion = jarMatcher.group(2); //String jarExtra = jarMatcher.group(3); version = jarVersion; //Sets addon,pkg,version(si redefini) et addonClass - unassignedClassLoader = new JuliaClassLoader(jar, entriesToRead); + unassignedClassLoader = new JuliaClassLoader(jar, entriesToRead,new DummyLaboratory()); } + + public synchronized JuliaClassLoader newClassLoader(Laboratory laboratory) { - if(unassignedClassLoader==null) + if(unassignedClassLoader==null) try { - JuliaClassLoader cl = new JuliaClassLoader(jarFile, loaderEntries); - cl.laboratory = laboratory; + JuliaClassLoader cl = new JuliaClassLoader(jarFile, loaderEntries,laboratory); classLoaders.put(laboratory.laboratory, cl); return cl; } catch (JarWithMultipleAddonsException e) { System.err.println("Cette erreur n'est pas censée arriver, alerte rouge"); System.exit(685533990); } + JuliaClassLoader cl = unassignedClassLoader; unassignedClassLoader = null; cl.laboratory = laboratory; @@ -79,10 +82,18 @@ public class JuliaAddon { return cl; } + + public String getName() { return addon.name(); } + public String getVersion() { + return version; + } + + + public class JuliaClassLoader extends ClassLoader { Map> loadedClasses; @@ -91,9 +102,10 @@ public class JuliaAddon { HashSet registeredCommands; HashSet registeredEvents; - public JuliaClassLoader(JarFile jar,Set entriesToRead) throws JarWithMultipleAddonsException { + public JuliaClassLoader(JarFile jar,Set entriesToRead,Laboratory labo) throws JarWithMultipleAddonsException { super(); - + loadedClasses = new HashMap<>(); + this.laboratory = labo; Set> readClasses = new HashSet<>(); Map juliaddons = new HashMap<>(); for(JarEntry entry : entriesToRead) { @@ -182,7 +194,6 @@ 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 - loadedClasses = new HashMap<>(); for(Class clazz : readClasses) loadedClasses.put(clazz.getName(), clazz); @@ -193,7 +204,7 @@ 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); JuliaClassLoader cl = laboratory.findClassLoader(name); if(cl != null) try { @@ -271,4 +282,12 @@ public class JuliaAddon { } + public static final class DummyLaboratory extends Julia.Laboratory{ + + public DummyLaboratory() { + Julia.theJulia().super(Character.MIN_VALUE); + } + + } + } diff --git a/src/main/java/com/bernard/juliabot/api/Command.java b/src/main/java/com/bernard/juliabot/api/Command.java index 07a2b80..af9a9f8 100644 --- a/src/main/java/com/bernard/juliabot/api/Command.java +++ b/src/main/java/com/bernard/juliabot/api/Command.java @@ -9,6 +9,7 @@ public @interface Command { public String name(); public String[] aliases() default {}; public String description(); + public String synopsis() default ""; public boolean admin();//TODO a remplacer par les permissions } \ No newline at end of file