From c456837148582ab296480233aa4a8754dc84e92e Mon Sep 17 00:00:00 2001 From: Mysaa Date: Sun, 23 May 2021 02:47:29 +0200 Subject: [PATCH] =?UTF-8?q?Petite=20mise=20=C3=A0=20jour=20des=20=C3=A9ven?= =?UTF-8?q?ements?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- build.gradle | 4 +- .../com/bernard/juliabot/EcouteurDEvents.java | 909 ++++++++++++------ src/main/java/com/bernard/juliabot/Julia.java | 183 ++-- .../java/com/bernard/juliabot/JuliaAddon.java | 6 +- .../bernard/juliabot/JuliaErrPrintStream.java | 4 +- .../juliabot/api/DiscordCCommande.java | 7 +- .../com/bernard/juliabot/api/JuLIAddon.java | 13 +- .../com/bernard/juliabot/api/Trukilie.java | 4 +- .../juliabot/internaddon/Internaddon.java | 33 +- .../juliabot/internaddon/UnstableMessage.java | 5 +- 10 files changed, 805 insertions(+), 363 deletions(-) diff --git a/build.gradle b/build.gradle index dc283b1..4a55be4 100644 --- a/build.gradle +++ b/build.gradle @@ -73,14 +73,14 @@ dependencies { compile 'org.slf4j:slf4j-nop:1.7.25' - compile 'net.dv8tion:JDA:3.8.1_439' + compile 'net.dv8tion:JDA:4.2.0_189' 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' + compile group: 'mysql', name: 'mysql-connector-java', version: '8.0.21' } diff --git a/src/main/java/com/bernard/juliabot/EcouteurDEvents.java b/src/main/java/com/bernard/juliabot/EcouteurDEvents.java index afead0b..b3d4565 100644 --- a/src/main/java/com/bernard/juliabot/EcouteurDEvents.java +++ b/src/main/java/com/bernard/juliabot/EcouteurDEvents.java @@ -1,50 +1,174 @@ package com.bernard.juliabot; -import java.io.*; +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; +import java.io.UnsupportedEncodingException; import java.nio.charset.StandardCharsets; -import java.sql.*; +import java.sql.Connection; +import java.sql.Date; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.SQLIntegrityConstraintViolationException; +import java.sql.Statement; +import java.sql.Timestamp; import java.time.Instant; -import java.util.*; +import java.util.ArrayList; +import java.util.List; +import java.util.Queue; import java.util.concurrent.ConcurrentLinkedQueue; import java.util.stream.Collectors; import com.mysql.cj.jdbc.Blob; -import net.dv8tion.jda.client.events.call.GenericCallEvent; -import net.dv8tion.jda.client.events.group.GenericGroupEvent; -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.*; -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.*; -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.*; -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; +import net.dv8tion.jda.api.entities.Activity; +import net.dv8tion.jda.api.entities.Activity.Emoji; +import net.dv8tion.jda.api.entities.ChannelType; +import net.dv8tion.jda.api.entities.IPermissionHolder; +import net.dv8tion.jda.api.entities.Member; +import net.dv8tion.jda.api.entities.Message; +import net.dv8tion.jda.api.entities.MessageEmbed; +import net.dv8tion.jda.api.entities.MessageReaction; +import net.dv8tion.jda.api.entities.MessageReaction.ReactionEmote; +import net.dv8tion.jda.api.entities.Role; +import net.dv8tion.jda.api.entities.SelfUser; +import net.dv8tion.jda.api.events.DisconnectEvent; +import net.dv8tion.jda.api.events.ExceptionEvent; +import net.dv8tion.jda.api.events.GatewayPingEvent; +import net.dv8tion.jda.api.events.GenericEvent; +import net.dv8tion.jda.api.events.RawGatewayEvent; +import net.dv8tion.jda.api.events.ReadyEvent; +import net.dv8tion.jda.api.events.ShutdownEvent; +import net.dv8tion.jda.api.events.StatusChangeEvent; +import net.dv8tion.jda.api.events.channel.category.CategoryCreateEvent; +import net.dv8tion.jda.api.events.channel.category.CategoryDeleteEvent; +import net.dv8tion.jda.api.events.channel.category.GenericCategoryEvent; +import net.dv8tion.jda.api.events.channel.category.update.CategoryUpdateNameEvent; +import net.dv8tion.jda.api.events.channel.category.update.CategoryUpdatePositionEvent; +import net.dv8tion.jda.api.events.channel.priv.PrivateChannelCreateEvent; +import net.dv8tion.jda.api.events.channel.priv.PrivateChannelDeleteEvent; +import net.dv8tion.jda.api.events.channel.store.GenericStoreChannelEvent; +import net.dv8tion.jda.api.events.channel.store.StoreChannelCreateEvent; +import net.dv8tion.jda.api.events.channel.store.StoreChannelDeleteEvent; +import net.dv8tion.jda.api.events.channel.store.update.StoreChannelUpdateNameEvent; +import net.dv8tion.jda.api.events.channel.store.update.StoreChannelUpdatePositionEvent; +import net.dv8tion.jda.api.events.channel.text.GenericTextChannelEvent; +import net.dv8tion.jda.api.events.channel.text.TextChannelCreateEvent; +import net.dv8tion.jda.api.events.channel.text.TextChannelDeleteEvent; +import net.dv8tion.jda.api.events.channel.text.update.TextChannelUpdateNSFWEvent; +import net.dv8tion.jda.api.events.channel.text.update.TextChannelUpdateNameEvent; +import net.dv8tion.jda.api.events.channel.text.update.TextChannelUpdateParentEvent; +import net.dv8tion.jda.api.events.channel.text.update.TextChannelUpdatePositionEvent; +import net.dv8tion.jda.api.events.channel.text.update.TextChannelUpdateSlowmodeEvent; +import net.dv8tion.jda.api.events.channel.text.update.TextChannelUpdateTopicEvent; +import net.dv8tion.jda.api.events.channel.voice.GenericVoiceChannelEvent; +import net.dv8tion.jda.api.events.channel.voice.VoiceChannelCreateEvent; +import net.dv8tion.jda.api.events.channel.voice.VoiceChannelDeleteEvent; +import net.dv8tion.jda.api.events.channel.voice.update.VoiceChannelUpdateBitrateEvent; +import net.dv8tion.jda.api.events.channel.voice.update.VoiceChannelUpdateNameEvent; +import net.dv8tion.jda.api.events.channel.voice.update.VoiceChannelUpdateParentEvent; +import net.dv8tion.jda.api.events.channel.voice.update.VoiceChannelUpdatePositionEvent; +import net.dv8tion.jda.api.events.channel.voice.update.VoiceChannelUpdateUserLimitEvent; +import net.dv8tion.jda.api.events.emote.EmoteAddedEvent; +import net.dv8tion.jda.api.events.emote.EmoteRemovedEvent; +import net.dv8tion.jda.api.events.emote.GenericEmoteEvent; +import net.dv8tion.jda.api.events.emote.update.EmoteUpdateNameEvent; +import net.dv8tion.jda.api.events.emote.update.EmoteUpdateRolesEvent; +import net.dv8tion.jda.api.events.guild.GenericGuildEvent; +import net.dv8tion.jda.api.events.guild.GuildAvailableEvent; +import net.dv8tion.jda.api.events.guild.GuildBanEvent; +import net.dv8tion.jda.api.events.guild.GuildJoinEvent; +import net.dv8tion.jda.api.events.guild.GuildLeaveEvent; +import net.dv8tion.jda.api.events.guild.GuildReadyEvent; +import net.dv8tion.jda.api.events.guild.GuildUnavailableEvent; +import net.dv8tion.jda.api.events.guild.GuildUnbanEvent; +import net.dv8tion.jda.api.events.guild.UnavailableGuildJoinedEvent; +import net.dv8tion.jda.api.events.guild.UnavailableGuildLeaveEvent; +import net.dv8tion.jda.api.events.guild.invite.GuildInviteCreateEvent; +import net.dv8tion.jda.api.events.guild.invite.GuildInviteDeleteEvent; +import net.dv8tion.jda.api.events.guild.member.GuildMemberJoinEvent; +import net.dv8tion.jda.api.events.guild.member.GuildMemberRemoveEvent; +import net.dv8tion.jda.api.events.guild.member.GuildMemberRoleAddEvent; +import net.dv8tion.jda.api.events.guild.member.GuildMemberRoleRemoveEvent; +import net.dv8tion.jda.api.events.guild.member.update.GuildMemberUpdateBoostTimeEvent; +import net.dv8tion.jda.api.events.guild.member.update.GuildMemberUpdateNicknameEvent; +import net.dv8tion.jda.api.events.guild.override.PermissionOverrideCreateEvent; +import net.dv8tion.jda.api.events.guild.override.PermissionOverrideDeleteEvent; +import net.dv8tion.jda.api.events.guild.override.PermissionOverrideUpdateEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateAfkChannelEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateAfkTimeoutEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateBannerEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateBoostCountEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateBoostTierEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateDescriptionEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateExplicitContentLevelEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateFeaturesEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateIconEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateMFALevelEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateMaxMembersEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateMaxPresencesEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateNameEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateNotificationLevelEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateOwnerEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateRegionEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateSplashEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateSystemChannelEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateVanityCodeEvent; +import net.dv8tion.jda.api.events.guild.update.GuildUpdateVerificationLevelEvent; +import net.dv8tion.jda.api.events.guild.voice.GenericGuildVoiceEvent; +import net.dv8tion.jda.api.events.guild.voice.GuildVoiceDeafenEvent; +import net.dv8tion.jda.api.events.guild.voice.GuildVoiceGuildDeafenEvent; +import net.dv8tion.jda.api.events.guild.voice.GuildVoiceGuildMuteEvent; +import net.dv8tion.jda.api.events.guild.voice.GuildVoiceJoinEvent; +import net.dv8tion.jda.api.events.guild.voice.GuildVoiceLeaveEvent; +import net.dv8tion.jda.api.events.guild.voice.GuildVoiceMoveEvent; +import net.dv8tion.jda.api.events.guild.voice.GuildVoiceMuteEvent; +import net.dv8tion.jda.api.events.guild.voice.GuildVoiceSelfDeafenEvent; +import net.dv8tion.jda.api.events.guild.voice.GuildVoiceSelfMuteEvent; +import net.dv8tion.jda.api.events.guild.voice.GuildVoiceStreamEvent; +import net.dv8tion.jda.api.events.guild.voice.GuildVoiceSuppressEvent; +import net.dv8tion.jda.api.events.message.GenericMessageEvent; +import net.dv8tion.jda.api.events.message.MessageBulkDeleteEvent; +import net.dv8tion.jda.api.events.message.guild.GenericGuildMessageEvent; +import net.dv8tion.jda.api.events.message.guild.GuildMessageDeleteEvent; +import net.dv8tion.jda.api.events.message.guild.GuildMessageEmbedEvent; +import net.dv8tion.jda.api.events.message.guild.GuildMessageReceivedEvent; +import net.dv8tion.jda.api.events.message.guild.GuildMessageUpdateEvent; +import net.dv8tion.jda.api.events.message.guild.react.GuildMessageReactionAddEvent; +import net.dv8tion.jda.api.events.message.guild.react.GuildMessageReactionRemoveAllEvent; +import net.dv8tion.jda.api.events.message.guild.react.GuildMessageReactionRemoveEmoteEvent; +import net.dv8tion.jda.api.events.message.guild.react.GuildMessageReactionRemoveEvent; +import net.dv8tion.jda.api.events.message.priv.GenericPrivateMessageEvent; +import net.dv8tion.jda.api.events.message.priv.PrivateMessageDeleteEvent; +import net.dv8tion.jda.api.events.message.priv.PrivateMessageEmbedEvent; +import net.dv8tion.jda.api.events.message.priv.PrivateMessageReceivedEvent; +import net.dv8tion.jda.api.events.message.priv.PrivateMessageUpdateEvent; +import net.dv8tion.jda.api.events.message.priv.react.PrivateMessageReactionAddEvent; +import net.dv8tion.jda.api.events.message.priv.react.PrivateMessageReactionRemoveEvent; +import net.dv8tion.jda.api.events.role.GenericRoleEvent; +import net.dv8tion.jda.api.events.role.RoleCreateEvent; +import net.dv8tion.jda.api.events.role.RoleDeleteEvent; +import net.dv8tion.jda.api.events.role.update.RoleUpdateColorEvent; +import net.dv8tion.jda.api.events.role.update.RoleUpdateHoistedEvent; +import net.dv8tion.jda.api.events.role.update.RoleUpdateMentionableEvent; +import net.dv8tion.jda.api.events.role.update.RoleUpdateNameEvent; +import net.dv8tion.jda.api.events.role.update.RoleUpdatePermissionsEvent; +import net.dv8tion.jda.api.events.role.update.RoleUpdatePositionEvent; +import net.dv8tion.jda.api.events.self.SelfUpdateAvatarEvent; +import net.dv8tion.jda.api.events.self.SelfUpdateDiscriminatorEvent; +import net.dv8tion.jda.api.events.self.SelfUpdateMFAEvent; +import net.dv8tion.jda.api.events.self.SelfUpdateNameEvent; +import net.dv8tion.jda.api.events.self.SelfUpdateVerifiedEvent; +import net.dv8tion.jda.api.events.user.GenericUserEvent; +import net.dv8tion.jda.api.events.user.UserActivityEndEvent; +import net.dv8tion.jda.api.events.user.UserActivityStartEvent; +import net.dv8tion.jda.api.events.user.UserTypingEvent; +import net.dv8tion.jda.api.events.user.update.UserUpdateActivityOrderEvent; +import net.dv8tion.jda.api.events.user.update.UserUpdateAvatarEvent; +import net.dv8tion.jda.api.events.user.update.UserUpdateDiscriminatorEvent; +import net.dv8tion.jda.api.events.user.update.UserUpdateNameEvent; +import net.dv8tion.jda.api.events.user.update.UserUpdateOnlineStatusEvent; +import net.dv8tion.jda.api.hooks.EventListener; public class EcouteurDEvents implements EventListener{ @@ -72,51 +196,44 @@ public class EcouteurDEvents implements EventListener{ } @Override - public void onEvent(Event event) { + public void onEvent(GenericEvent event) { storeQueue.add(new PendingEventStore(event,Timestamp.from(Instant.now()))); - this.julia.laboratoires.get(getLabo(event)).trigger(event); + this.julia.getLaboratoires().get(getLabo(event)).trigger(event); } - public char getLabo(Event e) { + public char getLabo(GenericEvent event) { - if(GenericMessageEvent.class.isAssignableFrom(e.getClass())) - return g(((GenericMessageEvent)e).getChannel().getIdLong()); - if(GenericGuildMessageEvent.class.isAssignableFrom(e.getClass())) - return g(((GenericGuildMessageEvent)e).getChannel().getIdLong()); - if(GenericUserEvent.class.isAssignableFrom(e.getClass())) - return g(((GenericUserEvent)e).getUser().getIdLong()); - if(GenericGuildVoiceEvent.class.isAssignableFrom(e.getClass())) - return g(((GenericGuildVoiceEvent)e).getVoiceState().getChannel().getIdLong()); - if(GenericGuildEvent.class.isAssignableFrom(e.getClass())) - return g(((GenericGuildEvent)e).getGuild().getIdLong()); - if(GenericPrivateMessageEvent.class.isAssignableFrom(e.getClass())) - return g(((GenericPrivateMessageEvent)e).getChannel().getIdLong()); + if(GenericMessageEvent.class.isAssignableFrom(event.getClass())) + return g(((GenericMessageEvent)event).getChannel().getIdLong()); + if(GenericGuildMessageEvent.class.isAssignableFrom(event.getClass())) + return g(((GenericGuildMessageEvent)event).getChannel().getIdLong()); + if(GenericUserEvent.class.isAssignableFrom(event.getClass())) + return g(((GenericUserEvent)event).getUser().getIdLong()); + if(GenericGuildVoiceEvent.class.isAssignableFrom(event.getClass())) + return g(((GenericGuildVoiceEvent)event).getVoiceState().getChannel().getIdLong()); + if(GenericGuildEvent.class.isAssignableFrom(event.getClass())) + return g(((GenericGuildEvent)event).getGuild().getIdLong()); + if(GenericPrivateMessageEvent.class.isAssignableFrom(event.getClass())) + return g(((GenericPrivateMessageEvent)event).getChannel().getIdLong()); - if(e.getClass() == MessageBulkDeleteEvent.class) - return g(((MessageBulkDeleteEvent)e).getChannel().getIdLong()); - if(GenericTextChannelEvent.class.isAssignableFrom(e.getClass())) - return g(((GenericTextChannelEvent)e).getGuild().getIdLong()); - if(GenericVoiceChannelEvent.class.isAssignableFrom(e.getClass())) - return g(((GenericVoiceChannelEvent)e).getGuild().getIdLong()); - if(GenericCategoryEvent.class.isAssignableFrom(e.getClass())) - return g(((GenericCategoryEvent)e).getGuild().getIdLong()); - if(GenericRoleEvent.class.isAssignableFrom(e.getClass())) - return g(((GenericRoleEvent)e).getGuild().getIdLong()); - if(GenericEmoteEvent.class.isAssignableFrom(e.getClass())) - return g(((GenericEmoteEvent)e).getGuild().getIdLong()); - if(e.getClass() == PrivateChannelCreateEvent.class) - return g(((PrivateChannelCreateEvent)e).getUser().getIdLong()); - if(e.getClass() == PrivateChannelDeleteEvent.class) - return g(((PrivateChannelDeleteEvent)e).getUser().getIdLong()); - - if(GenericRelationshipEvent.class.isAssignableFrom(e.getClass())) - return g(((GenericRelationshipEvent)e).getUser().getIdLong()); - if(GenericGroupEvent.class.isAssignableFrom(e.getClass())) - return g(((GenericGroupEvent)e).getGroup().getIdLong()); - if(GenericGroupMessageEvent.class.isAssignableFrom(e.getClass())) - return g(((GenericEmoteEvent)e).getGuild().getIdLong()); - if(GenericCallEvent.class.isAssignableFrom(e.getClass())) - return g(((GenericCallEvent)e).getCall().isGroupCall()?((GenericCallEvent)e).getCall().getGroup().getIdLong():((GenericCallEvent)e).getCall().getPrivateChannel().getUser().getIdLong()); + if(event.getClass() == MessageBulkDeleteEvent.class) + return g(((MessageBulkDeleteEvent)event).getChannel().getIdLong()); + if(GenericTextChannelEvent.class.isAssignableFrom(event.getClass())) + return g(((GenericTextChannelEvent)event).getGuild().getIdLong()); + if(GenericVoiceChannelEvent.class.isAssignableFrom(event.getClass())) + return g(((GenericVoiceChannelEvent)event).getGuild().getIdLong()); + if(GenericStoreChannelEvent.class.isAssignableFrom(event.getClass())) + return g(((GenericVoiceChannelEvent)event).getGuild().getIdLong()); + if(GenericCategoryEvent.class.isAssignableFrom(event.getClass())) + return g(((GenericCategoryEvent)event).getGuild().getIdLong()); + if(GenericRoleEvent.class.isAssignableFrom(event.getClass())) + return g(((GenericRoleEvent)event).getGuild().getIdLong()); + if(GenericEmoteEvent.class.isAssignableFrom(event.getClass())) + return g(((GenericEmoteEvent)event).getGuild().getIdLong()); + if(event.getClass() == PrivateChannelCreateEvent.class) + return g(((PrivateChannelCreateEvent)event).getUser().getIdLong()); + if(event.getClass() == PrivateChannelDeleteEvent.class) + return g(((PrivateChannelDeleteEvent)event).getUser().getIdLong()); return '#'; } @@ -190,8 +307,8 @@ public class EcouteurDEvents implements EventListener{ return (state & 0b1000) == 0; } - public void storeEvent(Event event,Timestamp date) { - if(GenericMessageEvent.class.isAssignableFrom(event.getClass()))return;//Event non loggé + public void storeEvent(GenericEvent e2,Timestamp date) { + if(GenericMessageEvent.class.isAssignableFrom(e2.getClass()))return;//Event non loggé car doublon PreparedStatement s; Connection db = EcouteurDEvents.this.julia.eventDatabase; try { @@ -200,27 +317,26 @@ public class EcouteurDEvents implements EventListener{ PreparedStatement geidS = db.prepareStatement("INSERT INTO events VALUES (?,?,?,?)"); geidS.setLong(1, geid); geidS.setTimestamp(2, date); - geidS.setLong(3, event.getResponseNumber()); - geidS.setString(4, event.getClass().getName()); + geidS.setLong(3, e2.getResponseNumber()); + geidS.setString(4, e2.getClass().getName()); geidS.executeUpdate(); - switch(event.getClass().getSimpleName()) { - - + switch(e2.getClass().getSimpleName()) { + + ////////// Events ////////// case "DisconnectEvent": - DisconnectEvent e4 = (DisconnectEvent)event; - s = db.prepareStatement("INSERT INTO disconnectEvent VALUES (?,?,?,?,?,?,?)"); + DisconnectEvent e4 = (DisconnectEvent)e2; + s = db.prepareStatement("INSERT INTO disconnectEvent VALUES (?,?,?,?,?,?)"); s.setBlob(2, new Blob((e4.getClientCloseFrame()==null)?new byte[0]:((e4.getClientCloseFrame().getPayload())== null?new byte[0]:e4.getClientCloseFrame().getPayload()),null)); s.setString(3, (e4.getCloseCode()==null)?null:e4.getCloseCode().name()); - s.setDate(4, new java.sql.Date(e4.getDisconnectTime().toEpochSecond())); + s.setDate(4, new java.sql.Date(e4.getTimeDisconnected().toEpochSecond())); 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; + ExceptionEvent e5 = (ExceptionEvent)e2; s = db.prepareStatement("INSERT INTO exceptionEvent VALUES (?,?,?,?,?,?,?)"); s.setString(2, e5.getCause().getClass().getName()); s.setString(3, e5.getCause().getMessage()); @@ -236,7 +352,7 @@ public class EcouteurDEvents implements EventListener{ break; case "ReadyEvent": - ReadyEvent e6 = (ReadyEvent)event; + ReadyEvent e6 = (ReadyEvent)e2; s = db.prepareStatement("INSERT INTO readyEvent VALUES (?,?,?)"); s.setInt(2, e6.getGuildAvailableCount()); s.setInt(3, e6.getGuildUnavailableCount()); @@ -248,76 +364,84 @@ public class EcouteurDEvents implements EventListener{ s = db.prepareStatement("INSERT INTO reconnectedEvent VALUES (?)"); break; case "ShutdownEvent": - ShutdownEvent e7 = (ShutdownEvent)event; + ShutdownEvent e7 = (ShutdownEvent)e2; s = db.prepareStatement("INSERT INTO shutdownEvent VALUES (?,?,?)"); - s.setTimestamp(2, new Timestamp(e7.getShutdownTime().toEpochSecond())); + s.setTimestamp(2, new Timestamp(e7.getTimeShutdown().toEpochSecond())); s.setString(3, e7.getCloseCode().name()); break; case "StatusChangeEvent": - StatusChangeEvent e8 = (StatusChangeEvent)event; + StatusChangeEvent e8 = (StatusChangeEvent)e2; 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; + case "RawGatewayEvent": + RawGatewayEvent e8a = (RawGatewayEvent)e2; + s = db.prepareStatement("INSERT INTO rawGatewayEvent VALUES (?,?,?)"); + s.setString(2, e8a.getType()); + s.setString(3, new String(e8a.getPayload().toJson())); + break; + + case "GatewayPingEvent": + GatewayPingEvent e8b = (GatewayPingEvent)e2; + s = db.prepareStatement("INSERT INTO gatewayPingEvent VALUES (?,?,?,?)"); + s.setString(2, e8b.getPropertyIdentifier()); + s.setLong(3, e8b.getOldPing()); + s.setLong(4, e8b.getNewPing()); + break; + + case "MessageBulkDeleteEvent": + MessageBulkDeleteEvent e8c = (MessageBulkDeleteEvent)e2; + s = db.prepareStatement("INSERT INTO messageBulkDeleteEvent VALUES (?,?,?)"); + s.setLong(2, e8c.getChannel().getIdLong()); + s.setString(3, e8c.getMessageIds().stream().collect(Collectors.joining(","))); + break; + + case "UnavailableGuildJoinedEvent": + UnavailableGuildJoinedEvent e35a = (UnavailableGuildJoinedEvent)e2; + s = db.prepareStatement("INSERT INTO unavailableGuildJoinedEvent VALUES (?,?)"); + s.setLong(2, e35a.getGuildIdLong()); + break; + case "UnavailableGuildLeaveEvent": + UnavailableGuildLeaveEvent e35b = (UnavailableGuildLeaveEvent)e2; + s = db.prepareStatement("INSERT INTO unavailableGuildJoinedEvent VALUES (?,?)"); + s.setLong(2, e35b.getGuildIdLong()); + break; + + ////////// GenericSelfUpdateEvent ////////// case "SelfUpdateAvatarEvent": - SelfUpdateAvatarEvent e9 = (SelfUpdateAvatarEvent)event; + SelfUpdateAvatarEvent e9 = (SelfUpdateAvatarEvent)e2; 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; + SelfUpdateDiscriminatorEvent e10 = (SelfUpdateDiscriminatorEvent)e2; 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; + SelfUpdateMFAEvent e14 = (SelfUpdateMFAEvent)e2; 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; + SelfUpdateNameEvent e12 = (SelfUpdateNameEvent)e2; 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; + SelfUpdateVerifiedEvent e17 = (SelfUpdateVerifiedEvent)e2; s = db.prepareStatement("INSERT INTO selfUpdateVerifiedEvent VALUES (?,?,?)"); s.setLong(2, addSelfUser(e17.getSelfUser(), db)); s.setBoolean(3, e17.wasVerified()); @@ -326,67 +450,83 @@ public class EcouteurDEvents implements EventListener{ ////////// GenericUserEvent ////////// case "UserTypingEvent": - UserTypingEvent e18 = (UserTypingEvent)event; + UserTypingEvent e18 = (UserTypingEvent)e2; 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; + UserUpdateNameEvent e19 = (UserUpdateNameEvent)e2; 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; + UserUpdateDiscriminatorEvent e20 = (UserUpdateDiscriminatorEvent)e2; 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; + UserUpdateAvatarEvent e21 = (UserUpdateAvatarEvent)e2; 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; + UserUpdateOnlineStatusEvent e23 = (UserUpdateOnlineStatusEvent)e2; 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)); + s.setObject(4, e23.getOldOnlineStatus().name()); + s.setObject(5, e23.getNewOnlineStatus().name()); break; + case "UserUpdateActivityOrderEvent": + UserUpdateActivityOrderEvent e110= (UserUpdateActivityOrderEvent)e2; + s = db.prepareStatement("INSERT INTO userUpdateActivityOrderEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e110.getUser().getIdLong()); + s.setLong(3, e110.getGuild().getIdLong()); + s.setLong(4, addActivityList(e110.getOldValue(),db)); + s.setLong(5, addActivityList(e110.getNewValue(),db)); + break; + case "UserActivityStartEvent": + UserActivityStartEvent e111= (UserActivityStartEvent)e2; + s = db.prepareStatement("INSERT INTO userActivityStartEvent VALUES (?,?,?,?)"); + s.setLong(2, e111.getUser().getIdLong()); + s.setLong(3, e111.getGuild().getIdLong()); + s.setLong(4, addActivity(e111.getNewActivity(),db)); + break; + case "UserActivityEndEvent": + UserActivityEndEvent e112= (UserActivityEndEvent)e2; + s = db.prepareStatement("INSERT INTO userActivityEndEvent VALUES (?,?,?,?)"); + s.setLong(2, e112.getUser().getIdLong()); + s.setLong(3, e112.getGuild().getIdLong()); + s.setLong(4, addActivity(e112.getOldActivity(),db)); + break; + ////////// GenericPrivateMessageEvent ////////// case "PrivateMessageDeleteEvent": - PrivateMessageDeleteEvent e24 = (PrivateMessageDeleteEvent)event; + PrivateMessageDeleteEvent e24 = (PrivateMessageDeleteEvent)e2; 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; + PrivateMessageEmbedEvent e25 = (PrivateMessageEmbedEvent)e2; 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; + PrivateMessageReceivedEvent e26 = (PrivateMessageReceivedEvent)e2; int mID26 = addMessage(e26.getMessage(), db); s = db.prepareStatement("INSERT INTO privateMessageReceivedEvent VALUES (?,?,?,?,?)"); s.setLong(2, e26.getAuthor().getIdLong()); @@ -395,7 +535,7 @@ public class EcouteurDEvents implements EventListener{ s.setInt(5, mID26); break; case "PrivateMessageUpdateEvent": - PrivateMessageUpdateEvent e27 = (PrivateMessageUpdateEvent)event; + PrivateMessageUpdateEvent e27 = (PrivateMessageUpdateEvent)e2; int mID27 = addMessage(e27.getMessage(), db); s = db.prepareStatement("INSERT INTO privateMessageUpdateEvent VALUES (?,?,?,?,?)"); s.setLong(2, e27.getAuthor().getIdLong()); @@ -404,7 +544,7 @@ public class EcouteurDEvents implements EventListener{ s.setInt(5, mID27); break; case "PrivateMessageReactionAddEvent": - PrivateMessageReactionAddEvent e28 = (PrivateMessageReactionAddEvent)event; + PrivateMessageReactionAddEvent e28 = (PrivateMessageReactionAddEvent)e2; int mID28 = addMessageReaction(e28.getReaction(), db); s = db.prepareStatement("INSERT INTO privateMessageReactionAddEvent VALUES (?,?,?,?,?)"); s.setLong(2, e28.getChannel().getIdLong()); @@ -413,7 +553,7 @@ public class EcouteurDEvents implements EventListener{ s.setInt(5, mID28); break; case "PrivateMessageReactionRemoveEvent": - PrivateMessageReactionRemoveEvent e29 = (PrivateMessageReactionRemoveEvent)event; + PrivateMessageReactionRemoveEvent e29 = (PrivateMessageReactionRemoveEvent)e2; int mID29 = addMessageReaction(e29.getReaction(), db); s = db.prepareStatement("INSERT INTO privateMessageReactionRemoveEvent VALUES (?,?,?,?,?)"); s.setLong(2, e29.getChannel().getIdLong()); @@ -425,58 +565,77 @@ public class EcouteurDEvents implements EventListener{ ////////// GenericGuildEvent ////////// case "GuildReadyEvent": - GuildReadyEvent e30 = (GuildReadyEvent)event; + GuildReadyEvent e30 = (GuildReadyEvent)e2; s = db.prepareStatement("INSERT INTO guildReadyEvent VALUES (?,?)"); s.setLong(2, e30.getGuild().getIdLong()); break; case "GuildAvailableEvent": - GuildAvailableEvent e31 = (GuildAvailableEvent)event; + GuildAvailableEvent e31 = (GuildAvailableEvent)e2; s = db.prepareStatement("INSERT INTO guildAvailableEvent VALUES (?,?)"); s.setLong(2, e31.getGuild().getIdLong()); break; case "GuildBanEvent": - GuildBanEvent e32 = (GuildBanEvent)event; + GuildBanEvent e32 = (GuildBanEvent)e2; 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; + GuildJoinEvent e33 = (GuildJoinEvent)e2; s = db.prepareStatement("INSERT INTO guildJoinEvent VALUES (?,?)"); s.setLong(2, e33.getGuild().getIdLong()); break; case "GuildLeaveEvent": - GuildLeaveEvent e34 = (GuildLeaveEvent)event; + GuildLeaveEvent e34 = (GuildLeaveEvent)e2; s = db.prepareStatement("INSERT INTO guildLeaveEvent VALUES (?,?)"); s.setLong(2, e34.getGuild().getIdLong()); break; case "GuildUnavailableEvent": - GuildUnavailableEvent e35 = (GuildUnavailableEvent)event; + GuildUnavailableEvent e35 = (GuildUnavailableEvent)e2; s = db.prepareStatement("INSERT INTO guildUnavailableEvent VALUES (?,?)"); s.setLong(2, e35.getGuild().getIdLong()); break; case "GuildUnbanEvent": - GuildUnbanEvent e36 = (GuildUnbanEvent)event; + GuildUnbanEvent e36 = (GuildUnbanEvent)e2; s = db.prepareStatement("INSERT INTO guildUnanEvent VALUES (?,?,?)"); s.setLong(2, e36.getGuild().getIdLong()); s.setLong(3, e36.getUser().getIdLong()); break; + + case "GuildInviteCreateEvent": + GuildInviteCreateEvent e113 = (GuildInviteCreateEvent)e2; + s = db.prepareStatement("INSERT INTO guildInviteCreateEvent VALUES (?,?,?,?,?,?)"); + s.setLong(2, e113.getGuild().getIdLong()); + s.setString(3, e113.getChannelType().name()); + s.setLong(4, e113.getChannel().getIdLong()); + s.setString(5, e113.getInvite().getCode()); + s.setLong(6, e113.getInvite().getInviter()==null?null:e113.getInvite().getInviter().getIdLong()); + break; + + case "GuildInviteDeleteEvent": + GuildInviteDeleteEvent e114 = (GuildInviteDeleteEvent)e2; + s = db.prepareStatement("INSERT INTO guildInviteDeleteEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e114.getGuild().getIdLong()); + s.setString(3, e114.getChannelType().name()); + s.setLong(4, e114.getChannel().getIdLong()); + s.setString(5, e114.getCode()); + break; case "GuildMessageDeleteEvent": - GuildMessageDeleteEvent e37 = (GuildMessageDeleteEvent)event; + GuildMessageDeleteEvent e37 = (GuildMessageDeleteEvent)e2; 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; + GuildMessageEmbedEvent e38 = (GuildMessageEmbedEvent)e2; 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; + GuildMessageReceivedEvent e39 = (GuildMessageReceivedEvent)e2; int mID39 = addMessage(e39.getMessage(), db); s = db.prepareStatement("INSERT INTO guildMessageReceivedEvent VALUES (?,?,?,?,?)"); s.setLong(2, e39.getAuthor().getIdLong()); @@ -485,7 +644,7 @@ public class EcouteurDEvents implements EventListener{ s.setInt(5, mID39); break; case "GuildMessageUpdateEvent": - GuildMessageUpdateEvent e40 = (GuildMessageUpdateEvent)event; + GuildMessageUpdateEvent e40 = (GuildMessageUpdateEvent)e2; int mID40 = addMessage(e40.getMessage(), db); s = db.prepareStatement("INSERT INTO guildMessageUpdateEvent VALUES (?,?,?,?,?)"); s.setLong(2, e40.getAuthor().getIdLong()); @@ -494,13 +653,21 @@ public class EcouteurDEvents implements EventListener{ s.setInt(5, mID40); break; case "GuildMessageReactionRemoveAllEvent": - GuildMessageReactionRemoveAllEvent e40b = (GuildMessageReactionRemoveAllEvent)event; + GuildMessageReactionRemoveAllEvent e40b = (GuildMessageReactionRemoveAllEvent)e2; s = db.prepareStatement("INSERT INTO guildMessageReactionRemoveAllEvent VALUES (?,?,?)"); s.setLong(2, e40b.getChannel().getIdLong()); s.setLong(3, e40b.getMessageIdLong()); break; + case "GuildMessageReactionRemoveEmoteEvent": + GuildMessageReactionRemoveEmoteEvent e40c = (GuildMessageReactionRemoveEmoteEvent)e2; + s = db.prepareStatement("INSERT INTO guildMessageReactionRemoveEmoteEvent VALUES (?,?,?)"); + s.setLong(2, e40c.getChannel().getIdLong()); + s.setLong(3, e40c.getMessageIdLong()); + s.setString(4, rEmote(e40c.getReactionEmote())); + break; + case "GuildMessageReactionAddEvent": - GuildMessageReactionAddEvent e41 = (GuildMessageReactionAddEvent)event; + GuildMessageReactionAddEvent e41 = (GuildMessageReactionAddEvent)e2; int mID41 = addMessageReaction(e41.getReaction(), db); s = db.prepareStatement("INSERT INTO guildMessageReactionAddEvent VALUES (?,?,?,?,?)"); s.setLong(2, e41.getChannel().getIdLong()); @@ -509,7 +676,7 @@ public class EcouteurDEvents implements EventListener{ s.setInt(5, mID41); break; case "GuildMessageReactionRemoveEvent": - GuildMessageReactionRemoveEvent e42 = (GuildMessageReactionRemoveEvent)event; + GuildMessageReactionRemoveEvent e42 = (GuildMessageReactionRemoveEvent)e2; int mID42 = addMessageReaction(e42.getReaction(), db); s = db.prepareStatement("INSERT INTO guildMessageReactionRemoveEvent VALUES (?,?,?,?,?)"); s.setLong(2, e42.getChannel().getIdLong()); @@ -519,35 +686,35 @@ public class EcouteurDEvents implements EventListener{ break; case "GuildUpdateAfkChannelEvent": - GuildUpdateAfkChannelEvent e43 = (GuildUpdateAfkChannelEvent)event; + GuildUpdateAfkChannelEvent e43 = (GuildUpdateAfkChannelEvent)e2; 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; + GuildUpdateAfkTimeoutEvent e44 = (GuildUpdateAfkTimeoutEvent)e2; 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; + GuildUpdateExplicitContentLevelEvent e45 = (GuildUpdateExplicitContentLevelEvent)e2; 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; + GuildUpdateFeaturesEvent e46 = (GuildUpdateFeaturesEvent)e2; 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; + GuildUpdateIconEvent e47 = (GuildUpdateIconEvent)e2; s = db.prepareStatement("INSERT INTO guildUpdateIconEvent VALUES (?,?,?,?,?,?)"); s.setLong(2, e47.getGuild().getIdLong()); s.setString(3, e47.getOldIconUrl()); @@ -556,42 +723,42 @@ public class EcouteurDEvents implements EventListener{ s.setString(6, e47.getNewIconId()); break; case "GuildUpdateMFALevelEvent": - GuildUpdateMFALevelEvent e48 = (GuildUpdateMFALevelEvent)event; + GuildUpdateMFALevelEvent e48 = (GuildUpdateMFALevelEvent)e2; 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; + GuildUpdateNameEvent e49 = (GuildUpdateNameEvent)e2; 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; + GuildUpdateNotificationLevelEvent e50 = (GuildUpdateNotificationLevelEvent)e2; 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; + GuildUpdateOwnerEvent e51 = (GuildUpdateOwnerEvent)e2; 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; + GuildUpdateRegionEvent e52 = (GuildUpdateRegionEvent)e2; 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; + GuildUpdateSplashEvent e53 = (GuildUpdateSplashEvent)e2; s = db.prepareStatement("INSERT INTO guildUpdateSplashEvent VALUES (?,?,?,?)"); s.setLong(2, e53.getGuild().getIdLong()); s.setString(3, e53.getOldSplashUrl()); @@ -599,15 +766,72 @@ public class EcouteurDEvents implements EventListener{ s.setString(5, e53.getNewSplashUrl()); s.setString(6, e53.getNewSplashId()); break; + case "GuildUpdateSystemChannelEvent": - GuildUpdateSystemChannelEvent e54 = (GuildUpdateSystemChannelEvent)event; + GuildUpdateSystemChannelEvent e54 = (GuildUpdateSystemChannelEvent)e2; 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 "GuildUpdateBannerEvent": + GuildUpdateBannerEvent e115 = (GuildUpdateBannerEvent)e2; + s = db.prepareStatement("INSERT INTO guildUpdateBannerEvent VALUES (?,?,?,?)"); + s.setLong(2, e115.getGuild().getIdLong()); + s.setString(3, e115.getOldBannerId()); + s.setString(4, e115.getNewBannerId()); + break; + + case "GuildUpdateBoostCountEvent": + GuildUpdateBoostCountEvent e116 = (GuildUpdateBoostCountEvent)e2; + s = db.prepareStatement("INSERT INTO guildUpdateBoostCountEvent VALUES (?,?,?,?)"); + s.setLong(2, e116.getGuild().getIdLong()); + s.setInt(3, e116.getOldBoostCount()); + s.setInt(4, e116.getNewBoostCount()); + break; + + case "GuildUpdateBoostTierEvent": + GuildUpdateBoostTierEvent e117 = (GuildUpdateBoostTierEvent)e2; + s = db.prepareStatement("INSERT INTO guildUpdateBoostTierEvent VALUES (?,?,?,?)"); + s.setLong(2, e117.getGuild().getIdLong()); + s.setString(3, e117.getOldBoostTier().name()); + s.setString(4, e117.getNewBoostTier().name()); + break; + + case "GuildUpdateDescriptionEvent": + GuildUpdateDescriptionEvent e118 = (GuildUpdateDescriptionEvent)e2; + s = db.prepareStatement("INSERT INTO guildUpdateDescriptionEvent VALUES (?,?,?,?)"); + s.setLong(2, e118.getGuild().getIdLong()); + s.setString(3, e118.getOldDescription()); + s.setString(4, e118.getNewDescription()); + break; + + case "GuildUpdateMaxMembersEvent": + GuildUpdateMaxMembersEvent e119 = (GuildUpdateMaxMembersEvent)e2; + s = db.prepareStatement("INSERT INTO guildUpdateMaxMembersEvent VALUES (?,?,?,?)"); + s.setLong(2, e119.getGuild().getIdLong()); + s.setInt(3, e119.getOldMaxMembers()); + s.setInt(4, e119.getNewMaxMembers()); + break; + + case "GuildUpdateMaxPresencesEvent": + GuildUpdateMaxPresencesEvent e120 = (GuildUpdateMaxPresencesEvent)e2; + s = db.prepareStatement("INSERT INTO guildUpdateMaxPresencesEvent VALUES (?,?,?,?)"); + s.setLong(2, e120.getGuild().getIdLong()); + s.setInt(3, e120.getOldMaxPresences()); + s.setInt(4, e120.getNewMaxPresences()); + break; + + case "GuildUpdateVanityCodeEvent": + GuildUpdateVanityCodeEvent e121 = (GuildUpdateVanityCodeEvent)e2; + s = db.prepareStatement("INSERT INTO guildUpdateVanityCodeEvent VALUES (?,?,?,?)"); + s.setLong(2, e121.getGuild().getIdLong()); + s.setString(3, e121.getOldVanityCode()); + s.setString(4, e121.getNewVanityCode()); + break; + case "GuildUpdateVerificationLevelEvent": - GuildUpdateVerificationLevelEvent e55 = (GuildUpdateVerificationLevelEvent)event; + GuildUpdateVerificationLevelEvent e55 = (GuildUpdateVerificationLevelEvent)e2; s = db.prepareStatement("INSERT INTO guildUpdateVerificationLevelEvent VALUES (?,?,?,?)"); s.setLong(2, e55.getGuild().getIdLong()); s.setString(3, e55.getOldVerificationLevel().name()); @@ -615,34 +839,43 @@ public class EcouteurDEvents implements EventListener{ break; case "GuildMemberJoinEvent": - GuildMemberJoinEvent e56 = (GuildMemberJoinEvent)event; + GuildMemberJoinEvent e56 = (GuildMemberJoinEvent)e2; 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; + case "GuildMemberUpdateNicknameEvent": + GuildMemberUpdateNicknameEvent e57 = (GuildMemberUpdateNicknameEvent)e2; 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()); + s.setString(4, e57.getOldNickname()); + s.setString(5, e57.getNewNickname()); break; - case "GuildMemberLeaveEvent": - GuildMemberLeaveEvent e58 = (GuildMemberLeaveEvent)event; + case "GuildMemberUpdateBoostTimeEvent": + GuildMemberUpdateBoostTimeEvent e123 = (GuildMemberUpdateBoostTimeEvent)e2; + s = db.prepareStatement("INSERT INTO guildMemberUpdateBoostTimeEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e123.getGuild().getIdLong()); + s.setLong(3, e123.getUser().getIdLong()); + s.setDate(4, new Date(e123.getOldTimeBoosted().toEpochSecond())); + s.setDate(5, new Date(e123.getOldTimeBoosted().toEpochSecond())); + break; + + case "GuildMemberRemoveEvent": + GuildMemberRemoveEvent e58 = (GuildMemberRemoveEvent)e2; 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; + GuildMemberRoleAddEvent e59 = (GuildMemberRoleAddEvent)e2; 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; + GuildMemberRoleRemoveEvent e60 = (GuildMemberRoleRemoveEvent)e2; addRoles(geid, e60.getRoles(), db); s = db.prepareStatement("INSERT INTO guildMemberRoleRemoveEvent VALUES (?,?,?)"); s.setLong(2, e60.getGuild().getIdLong()); @@ -650,70 +883,80 @@ public class EcouteurDEvents implements EventListener{ break; case "GuildVoiceDeafenEvent": - GuildVoiceDeafenEvent e61 = (GuildVoiceDeafenEvent)event; + GuildVoiceDeafenEvent e61 = (GuildVoiceDeafenEvent)e2; 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; + GuildVoiceGuildDeafenEvent e62 = (GuildVoiceGuildDeafenEvent)e2; 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; + GuildVoiceGuildMuteEvent e63 = (GuildVoiceGuildMuteEvent)e2; 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; + GuildVoiceMuteEvent e64 = (GuildVoiceMuteEvent)e2; 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; + GuildVoiceSelfDeafenEvent e64b = (GuildVoiceSelfDeafenEvent)e2; 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 "GuildVoiceStreamEvent": + GuildVoiceStreamEvent e124 = (GuildVoiceStreamEvent)e2; + s = db.prepareStatement("INSERT INTO guildVoiceStreamEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e124.getGuild().getIdLong()); + s.setLong(3, e124.getMember().getUser().getIdLong()); + s.setLong(4, e124.getVoiceState().getChannel().getIdLong()); + s.setBoolean(5, e124.isStream()); + break; + case "GuildVoiceSelfMuteEvent": - GuildVoiceSelfMuteEvent e65 = (GuildVoiceSelfMuteEvent)event; + GuildVoiceSelfMuteEvent e65 = (GuildVoiceSelfMuteEvent)e2; 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; + GuildVoiceSuppressEvent e66 = (GuildVoiceSuppressEvent)e2; 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; + GuildVoiceJoinEvent e67 = (GuildVoiceJoinEvent)e2; 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; + GuildVoiceLeaveEvent e68 = (GuildVoiceLeaveEvent)e2; 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; + GuildVoiceMoveEvent e69 = (GuildVoiceMoveEvent)e2; s = db.prepareStatement("INSERT INTO guildVoiceMoveEvent VALUES (?,?,?,?,?)"); s.setLong(2, e69.getGuild().getIdLong()); s.setLong(3, e69.getMember().getUser().getIdLong()); @@ -721,35 +964,68 @@ public class EcouteurDEvents implements EventListener{ 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()); + + ////////// GenericPermissionOverrideEvent ////////// + + case "PermissionOverrideCreateEvent": + PermissionOverrideCreateEvent e73 = (PermissionOverrideCreateEvent)e2; + s = db.prepareStatement("INSERT INTO permissionOverrideCreateEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e73.getGuild().getIdLong()); + s.setLong(3, e73.getChannel().getIdLong()); + IPermissionHolder holder = e73.getPermissionHolder(); + s.setString(4, (holder.getClass().equals(Member.class))?"MEMBER":"ROLE"); + s.setLong(5, (holder.getClass().equals(Member.class))?((Member)holder).getUser().getIdLong():((Role)holder).getIdLong()); + s.setString(6, e73.getPermissionOverride().getAllowed().stream().map(perm->perm.name()).collect(Collectors.joining(","))); + s.setString(7, e73.getPermissionOverride().getDenied().stream().map(perm->perm.name()).collect(Collectors.joining(","))); + s.setString(8, e73.getPermissionOverride().getInherit().stream().map(perm->perm.name()).collect(Collectors.joining(","))); break; + + case "PermissionOverrideDeleteEvent": + PermissionOverrideDeleteEvent e73a = (PermissionOverrideDeleteEvent)e2; + s = db.prepareStatement("INSERT INTO permissionOverrideDeleteEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e73a.getGuild().getIdLong()); + s.setLong(3, e73a.getChannel().getIdLong()); + IPermissionHolder holdera = e73a.getPermissionHolder(); + s.setString(4, (holdera.getClass().equals(Member.class))?"MEMBER":"ROLE"); + s.setLong(5, (holdera.getClass().equals(Member.class))?((Member)holdera).getUser().getIdLong():((Role)holdera).getIdLong()); + s.setString(6, e73a.getPermissionOverride().getAllowed().stream().map(perm->perm.name()).collect(Collectors.joining(","))); + s.setString(7, e73a.getPermissionOverride().getDenied().stream().map(perm->perm.name()).collect(Collectors.joining(","))); + s.setString(8, e73a.getPermissionOverride().getInherit().stream().map(perm->perm.name()).collect(Collectors.joining(","))); + break; + + case "PermissionOverrideUpdateEvent": + PermissionOverrideUpdateEvent e73b = (PermissionOverrideUpdateEvent)e2; + s = db.prepareStatement("INSERT INTO permissionOverrideDeleteEvent VALUES (?,?,?,?,?,?)"); + s.setLong(2, e73b.getGuild().getIdLong()); + s.setLong(3, e73b.getChannel().getIdLong()); + IPermissionHolder holderb = e73b.getPermissionHolder(); + s.setString(4, (holderb.getClass().equals(Member.class))?"MEMBER":"ROLE"); + s.setLong(5, (holderb.getClass().equals(Member.class))?((Member)holderb).getUser().getIdLong():((Role)holderb).getIdLong()); + s.setString(6, e73b.getOldAllow().stream().map(perm->perm.name()).collect(Collectors.joining(","))); + s.setString(7, e73b.getOldDeny().stream().map(perm->perm.name()).collect(Collectors.joining(","))); + s.setString(8, e73b.getOldInherited().stream().map(perm->perm.name()).collect(Collectors.joining(","))); + s.setString(9, e73b.getPermissionOverride().getAllowed().stream().map(perm->perm.name()).collect(Collectors.joining(","))); + s.setString(10, e73b.getPermissionOverride().getDenied().stream().map(perm->perm.name()).collect(Collectors.joining(","))); + s.setString(11, e73b.getPermissionOverride().getInherit().stream().map(perm->perm.name()).collect(Collectors.joining(","))); + break; + ////////// GenericTextChannelEvent ////////// case "TextChannelCreateEvent": - TextChannelCreateEvent e71 = (TextChannelCreateEvent)event; + TextChannelCreateEvent e71 = (TextChannelCreateEvent)e2; 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; + TextChannelDeleteEvent e72 = (TextChannelDeleteEvent)e2; 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; + TextChannelUpdateNameEvent e74 = (TextChannelUpdateNameEvent)e2; s = db.prepareStatement("INSERT INTO textChannelUpdateNameEvent VALUES (?,?,?,?,?)"); s.setLong(2, e74.getGuild().getIdLong()); s.setLong(3, e74.getChannel().getIdLong()); @@ -757,14 +1033,14 @@ public class EcouteurDEvents implements EventListener{ s.setString(5, e74.getNewName()); break; case "TextChannelUpdateNSFWEvent": - TextChannelUpdateNSFWEvent e75 = (TextChannelUpdateNSFWEvent)event; + TextChannelUpdateNSFWEvent e75 = (TextChannelUpdateNSFWEvent)e2; 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; + TextChannelUpdateParentEvent e76 = (TextChannelUpdateParentEvent)e2; s = db.prepareStatement("INSERT INTO textChannelUpdateParentEvent VALUES (?,?,?,?,?)"); s.setLong(2, e76.getGuild().getIdLong()); s.setLong(3, e76.getChannel().getIdLong()); @@ -772,15 +1048,25 @@ public class EcouteurDEvents implements EventListener{ s.setLong(5, e76.getNewParent().getIdLong()); break; case "TextChannelUpdatePositionEvent": - TextChannelUpdatePositionEvent e77 = (TextChannelUpdatePositionEvent)event; + TextChannelUpdatePositionEvent e77 = (TextChannelUpdatePositionEvent)e2; 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 "TextChannelUpdateSlowmodeEvent": + TextChannelUpdateSlowmodeEvent e125 = (TextChannelUpdateSlowmodeEvent)e2; + s = db.prepareStatement("INSERT INTO textChannelUpdateSlowmodeEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e125.getGuild().getIdLong()); + s.setLong(3, e125.getChannel().getIdLong()); + s.setInt(4, e125.getOldSlowmode()); + s.setInt(5, e125.getNewSlowmode()); + break; + case "TextChannelUpdateTopicEvent": - TextChannelUpdateTopicEvent e78 = (TextChannelUpdateTopicEvent)event; + TextChannelUpdateTopicEvent e78 = (TextChannelUpdateTopicEvent)e2; s = db.prepareStatement("INSERT INTO textChannelUpdateTopicEvent VALUES (?,?,?,?,?)"); s.setLong(2, e78.getGuild().getIdLong()); s.setLong(3, e78.getChannel().getIdLong()); @@ -791,26 +1077,19 @@ public class EcouteurDEvents implements EventListener{ ////////// GenericTextChannelEvent ////////// case "VoiceChannelCreateEvent": - VoiceChannelCreateEvent e79 = (VoiceChannelCreateEvent)event; + VoiceChannelCreateEvent e79 = (VoiceChannelCreateEvent)e2; 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; + VoiceChannelDeleteEvent e80 = (VoiceChannelDeleteEvent)e2; 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; + VoiceChannelUpdateBitrateEvent e82 = (VoiceChannelUpdateBitrateEvent)e2; s = db.prepareStatement("INSERT INTO voiceChannelUpdateBitrateEvent VALUES (?,?,?,?,?)"); s.setLong(2, e82.getGuild().getIdLong()); s.setLong(3, e82.getChannel().getIdLong()); @@ -818,7 +1097,7 @@ public class EcouteurDEvents implements EventListener{ s.setInt(5, e82.getNewBitrate()); break; case "VoiceChannelUpdateNameEvent": - VoiceChannelUpdateNameEvent e83 = (VoiceChannelUpdateNameEvent)event; + VoiceChannelUpdateNameEvent e83 = (VoiceChannelUpdateNameEvent)e2; s = db.prepareStatement("INSERT INTO voiceChannelUpdateNameEvent VALUES (?,?,?,?,?)"); s.setLong(2, e83.getGuild().getIdLong()); s.setLong(3, e83.getChannel().getIdLong()); @@ -826,7 +1105,7 @@ public class EcouteurDEvents implements EventListener{ s.setString(5, e83.getNewName()); break; case "VoiceChannelUpdateParentEvent": - VoiceChannelUpdateParentEvent e84 = (VoiceChannelUpdateParentEvent)event; + VoiceChannelUpdateParentEvent e84 = (VoiceChannelUpdateParentEvent)e2; s = db.prepareStatement("INSERT INTO voiceChannelUpdateParentEvent VALUES (?,?,?,?,?)"); s.setLong(2, e84.getGuild().getIdLong()); s.setLong(3, e84.getChannel().getIdLong()); @@ -834,7 +1113,7 @@ public class EcouteurDEvents implements EventListener{ s.setLong(5, e84.getNewParent().getIdLong()); break; case "VoiceChannelUpdatePositionEvent": - VoiceChannelUpdatePositionEvent e85 = (VoiceChannelUpdatePositionEvent)event; + VoiceChannelUpdatePositionEvent e85 = (VoiceChannelUpdatePositionEvent)e2; s = db.prepareStatement("INSERT INTO voiceChannelUpdatePositionEvent VALUES (?,?,?,?,?)"); s.setLong(2, e85.getGuild().getIdLong()); s.setLong(3, e85.getChannel().getIdLong()); @@ -842,7 +1121,7 @@ public class EcouteurDEvents implements EventListener{ s.setInt(5, e85.getNewPosition()); break; case "VoiceChannelUpdateUserLimitEvent": - VoiceChannelUpdateUserLimitEvent e86 = (VoiceChannelUpdateUserLimitEvent)event; + VoiceChannelUpdateUserLimitEvent e86 = (VoiceChannelUpdateUserLimitEvent)e2; s = db.prepareStatement("INSERT INTO voiceChannelUpdateUserLimitEvent VALUES (?,?,?,?,?)"); s.setLong(2, e86.getGuild().getIdLong()); s.setLong(3, e86.getChannel().getIdLong()); @@ -853,26 +1132,19 @@ public class EcouteurDEvents implements EventListener{ ////////// GenericCategoryEvent ////////// case "CategoryCreateEvent": - CategoryCreateEvent e87 = (CategoryCreateEvent)event; + CategoryCreateEvent e87 = (CategoryCreateEvent)e2; 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; + CategoryDeleteEvent e88 = (CategoryDeleteEvent)e2; 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; + CategoryUpdateNameEvent e90 = (CategoryUpdateNameEvent)e2; s = db.prepareStatement("INSERT INTO categoryUpdateNameEvent VALUES (?,?,?,?,?)"); s.setLong(2, e90.getGuild().getIdLong()); s.setLong(3, e90.getCategory().getIdLong()); @@ -880,24 +1152,55 @@ public class EcouteurDEvents implements EventListener{ s.setString(5, e90.getNewName()); break; case "CategoryUpdatePositionEvent": - CategoryUpdatePositionEvent e91 = (CategoryUpdatePositionEvent)event; + CategoryUpdatePositionEvent e91 = (CategoryUpdatePositionEvent)e2; 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; - + + + ////////// GenericStoreChannelEvent ////////// + + case "StoreChannelCreateEvent": + StoreChannelCreateEvent e129 = (StoreChannelCreateEvent)e2; + s = db.prepareStatement("INSERT INTO storeChannelCreateEvent VALUES (?,?,?)"); + s.setLong(2, e129.getChannel().getGuild().getIdLong()); + s.setLong(3, e129.getChannel().getIdLong()); + break; + case "StoreChannelDeleteEvent": + StoreChannelDeleteEvent e126 = (StoreChannelDeleteEvent)e2; + s = db.prepareStatement("INSERT INTO storeChannelDeleteEvent VALUES (?,?,?)"); + s.setLong(2, e126.getChannel().getGuild().getIdLong()); + s.setLong(3, e126.getChannel().getIdLong()); + break; + case "StoreChannelUpdateNameEvent": + StoreChannelUpdateNameEvent e127 = (StoreChannelUpdateNameEvent)e2; + s = db.prepareStatement("INSERT INTO storeChannelUpdateNameEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e127.getChannel().getGuild().getIdLong()); + s.setLong(3, e127.getChannel().getIdLong()); + s.setString(4, e127.getOldName()); + s.setString(5, e127.getNewName()); + break; + case "StoreChannelUpdatePositionEvent": + StoreChannelUpdatePositionEvent e128 = (StoreChannelUpdatePositionEvent)e2; + s = db.prepareStatement("INSERT INTO storeChannelUpdatePositionEvent VALUES (?,?,?,?,?)"); + s.setLong(2, e128.getChannel().getGuild().getIdLong()); + s.setLong(3, e128.getChannel().getIdLong()); + s.setInt(4, e128.getOldPosition()); + s.setInt(5, e128.getNewPosition()); + break; ////////// GenericPrivateChannelEvent ////////// case "PrivateChannelCreateEvent": - PrivateChannelCreateEvent e92 = (PrivateChannelCreateEvent)event; + PrivateChannelCreateEvent e92 = (PrivateChannelCreateEvent)e2; 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; + PrivateChannelDeleteEvent e93 = (PrivateChannelDeleteEvent)e2; s = db.prepareStatement("INSERT INTO privateChannelDeleteEvent VALUES (?,?,?)"); s.setLong(2, e93.getUser().getIdLong()); s.setLong(3, e93.getChannel().getIdLong()); @@ -906,19 +1209,19 @@ public class EcouteurDEvents implements EventListener{ ////////// GenericRoleEvent ////////// case "RoleCreateEvent": - RoleCreateEvent e94 = (RoleCreateEvent)event; + RoleCreateEvent e94 = (RoleCreateEvent)e2; 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; + RoleDeleteEvent e95 = (RoleDeleteEvent)e2; 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; + RoleUpdateColorEvent e97 = (RoleUpdateColorEvent)e2; s = db.prepareStatement("INSERT INTO roleUpdateColorEvent VALUES (?,?,?,?,?)"); s.setLong(2, e97.getGuild().getIdLong()); s.setLong(3, e97.getRole().getIdLong()); @@ -926,21 +1229,21 @@ public class EcouteurDEvents implements EventListener{ s.setInt(5, e97.getNewColorRaw()); break; case "RoleUpdateHoistedEvent": - RoleUpdateHoistedEvent e98 = (RoleUpdateHoistedEvent)event; + RoleUpdateHoistedEvent e98 = (RoleUpdateHoistedEvent)e2; 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; + RoleUpdateMentionableEvent e101 = (RoleUpdateMentionableEvent)e2; 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; + RoleUpdateNameEvent e99 = (RoleUpdateNameEvent)e2; s = db.prepareStatement("INSERT INTO roleUpdateNameEvent VALUES (?,?,?,?,?)"); s.setLong(2, e99.getGuild().getIdLong()); s.setLong(3, e99.getRole().getIdLong()); @@ -948,7 +1251,7 @@ public class EcouteurDEvents implements EventListener{ s.setString(5, e99.getNewName()); break; case "RoleUpdatePermissionsEvent": - RoleUpdatePermissionsEvent e96 = (RoleUpdatePermissionsEvent)event; + RoleUpdatePermissionsEvent e96 = (RoleUpdatePermissionsEvent)e2; s = db.prepareStatement("INSERT INTO roleUpdatePermissionsEvent VALUES (?,?,?,?,?)"); s.setLong(2, e96.getGuild().getIdLong()); s.setLong(3, e96.getRole().getIdLong()); @@ -956,7 +1259,7 @@ public class EcouteurDEvents implements EventListener{ s.setString(5, e96.getNewPermissions().stream().map(perm -> perm.name()).collect(Collectors.joining(","))); break; case "RoleUpdatePositionEvent": - RoleUpdatePositionEvent e100 = (RoleUpdatePositionEvent)event; + RoleUpdatePositionEvent e100 = (RoleUpdatePositionEvent)e2; s = db.prepareStatement("INSERT INTO roleUpdatePositionEvent VALUES (?,?,?,?,?)"); s.setLong(2, e100.getGuild().getIdLong()); s.setLong(3, e100.getRole().getIdLong()); @@ -967,21 +1270,21 @@ public class EcouteurDEvents implements EventListener{ ////////// GenericEmote ////////// case "EmoteAddedEvent": - EmoteAddedEvent e102 = (EmoteAddedEvent)event; + EmoteAddedEvent e102 = (EmoteAddedEvent)e2; 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; + EmoteRemovedEvent e103 = (EmoteRemovedEvent)e2; 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; + EmoteUpdateNameEvent e104 = (EmoteUpdateNameEvent)e2; s = db.prepareStatement("INSERT INTO emoteUpdateNameEvent VALUES (?,?,?,?,?,?)"); s.setLong(2, e104.getGuild().getIdLong()); s.setLong(3, e104.getEmote().getIdLong()); @@ -990,7 +1293,7 @@ public class EcouteurDEvents implements EventListener{ s.setString(6, e104.getNewName()); break; case "EmoteUpdateRolesEvent": - EmoteUpdateRolesEvent e105 = (EmoteUpdateRolesEvent)event; + EmoteUpdateRolesEvent e105 = (EmoteUpdateRolesEvent)e2; s = db.prepareStatement("INSERT INTO emoteUpdateRolesEvent VALUES (?,?,?,?,?,?)"); s.setLong(2, e105.getGuild().getIdLong()); s.setLong(3, e105.getEmote().getIdLong()); @@ -1010,7 +1313,7 @@ public class EcouteurDEvents implements EventListener{ //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()); + throw new IllegalStateException("Cette méthode n'est pas a jour avec le JDA ... je gère pas "+e2.getClass().getName()); } s.setLong(1, geid);//Le GEID s.executeUpdate(); @@ -1044,6 +1347,15 @@ public class EcouteurDEvents implements EventListener{ s.executeUpdate(); } } + public static void addPermissionHolder(long geid,IPermissionHolder holder, Connection db) throws SQLException { + PreparedStatement s = db.prepareStatement("INSERT INTO permissionUpdateHolders VALUES (NULL,?,?,?,?)"); + s.setLong(1, geid); + s.setString(2, (holder.getClass().equals(Member.class))?"MEMBER":"ROLE"); + s.setLong(3, (holder.getClass().equals(Member.class))?((Member)holder).getUser().getIdLong():((Role)holder).getIdLong()); + s.setString(4, holder.getPermissions().stream().map(perm->perm.name()).collect(Collectors.joining(","))); + s.executeUpdate(); + + } public static void addRoles(long geid,List roles, Connection db) throws SQLException { for(Role r : roles) { PreparedStatement s = db.prepareStatement("INSERT INTO role VALUES (NULL,?,?)"); @@ -1122,9 +1434,9 @@ public class EcouteurDEvents implements EventListener{ 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.setTimestamp(5, (m.isEdited())?new Timestamp(m.getTimeEdited().toEpochSecond()):null); + if(m.isFromType(ChannelType.PRIVATE))s.setLong(6, m.getChannel().getIdLong());else s.setObject(6, null); + if(m.isFromGuild())s.setLong(7, m.getGuild().getIdLong());else s.setObject(7, null); s.setString(8, m.getJumpUrl()); s.setBoolean(9, m.isPinned()); s.setBoolean(10, m.isTTS()); @@ -1142,7 +1454,7 @@ public class EcouteurDEvents implements EventListener{ s.setLong(2, r.getMessageIdLong()); s.setString(3, r.getReactionEmote().getName()); s.setLong(4, r.getReactionEmote().getIdLong()); - s.executeUpdate(); + s.execute(); ResultSet rs = s.getGeneratedKeys(); rs.next(); @@ -1151,16 +1463,12 @@ public class EcouteurDEvents implements EventListener{ 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()); + long hash = hash(""+user.getAllowedFileSize()+user.isVerified()+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 { @@ -1170,38 +1478,62 @@ public class EcouteurDEvents implements EventListener{ } return hash; } - public static Long addGame(Game g, Connection db) throws SQLException { + + + public static Long addActivityList(List la, Connection db) throws SQLException { + if(la==null)return null; + if(la.isEmpty())return 0L; + Statement s = db.createStatement(); + s.addBatch("SELECT MAX(listID) AS mid FROM activityListsItems"); + s.executeBatch(); + long id = s.getResultSet().getLong("mid")+1; + for (int i = 0; i < la.size(); i++) { + long aid = addActivity(la.get(i), db); + PreparedStatement s2 = db.prepareStatement("INSERT INTO activityListsItems VALUES (NULL,?,?)"); + s2.setLong(1, id); + s2.setLong(2, aid); + s2.executeUpdate(); + } + + return id; + } + + + public static Long addActivity(Activity g, Connection db) throws SQLException { if(g==null)return null; String h = ""; - PreparedStatement s = db.prepareStatement("INSERT INTO game VALUES (?,?,?,?,?,?,?,?,?,?,?,?,UNHEX(?),?,?,?,?)"); + PreparedStatement s = db.prepareStatement("INSERT INTO activities 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(); + s.setString(5, emoji(g.getEmoji()));h+=emoji(g.getEmoji()); 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():""; + s.setLong(6, g.asRichPresence().getApplicationIdLong());h+=g.asRichPresence().getApplicationIdLong(); + s.setString(7, g.asRichPresence().getDetails());h+=g.asRichPresence().getDetails(); + s.setString(8, g.asRichPresence().getFlagSet().stream().map(aflag -> aflag.name()).collect(Collectors.joining(",")));h+=g.asRichPresence().getFlags(); + s.setString(9, (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(); + s.setString(10,g.asRichPresence().getParty().getId());h+= g.asRichPresence().getParty().getId(); + s.setLong(11, g.asRichPresence().getParty().getMax());h+=g.asRichPresence().getParty().getMax(); + s.setLong(12, g.asRichPresence().getParty().getSize());h+=g.asRichPresence().getParty().getSize(); }else { - s.setObject(9, null); s.setObject(10, null); s.setObject(11, null); + s.setObject(12, 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():""; + s.setString(13, (g.asRichPresence().getSmallImage()!=null)?g.asRichPresence().getSmallImage().getUrl():null);h+=(g.asRichPresence().getSmallImage()!=null)?g.asRichPresence().getSmallImage().getUrl():""; + s.setObject(14, (g.asRichPresence().getSessionId()==null)?g.asRichPresence().getSessionId():null);h+=(g.asRichPresence().getSessionId()==null)?g.asRichPresence().getSessionId():""; + s.setObject(15, (g.asRichPresence().getSyncId()==null)?g.asRichPresence().getSyncId():null);h+=(g.asRichPresence().getSyncId()==null)?g.asRichPresence().getSyncId():""; + s.setString(16, g.asRichPresence().getState());h+=g.asRichPresence().getState(); }else { - for (int i = 5;i<=17;i++) + for (int i = 6;i<=16;i++) s.setObject(i, null); } + s.setTimestamp(17, (g.asRichPresence().getTimestamps()!=null)?new Timestamp(g.asRichPresence().getTimestamps().getStart()):null);h+=(g.asRichPresence().getTimestamps()!=null)?g.asRichPresence().getTimestamps().getStart():""; + s.setTimestamp(18, (g.asRichPresence().getTimestamps()!=null)?new Timestamp(g.asRichPresence().getTimestamps().getEnd()):null);h+=(g.asRichPresence().getTimestamps()!=null)?g.asRichPresence().getTimestamps().getEnd():""; + //TODO changer pour une clé plus grosse + //TODO rajouter une protection anti-doublon même avec le hash long hash = hash(h); s.setLong(1, hash); try { @@ -1211,6 +1543,8 @@ public class EcouteurDEvents implements EventListener{ } return hash; } + + public static long hash(String string) { long h = 1125899906842597L; // prime int len = string.length(); @@ -1231,15 +1565,15 @@ public class EcouteurDEvents implements EventListener{ public static class PendingEventStore { - Event e; + GenericEvent e; Timestamp eTime; - public PendingEventStore(Event e, Timestamp date) { - this.e = e; + public PendingEventStore(GenericEvent event, Timestamp date) { + this.e = event; this.eTime = date; } - public Event getE() { + public GenericEvent getE() { return e; } @@ -1255,4 +1589,17 @@ public class EcouteurDEvents implements EventListener{ return new String(c); } + public static String emoji(Emoji e) { + if(e==null)return "null"; + if(e.isEmoji())return e.getAsCodepoints(); + else return e.getId(); + } + public static String rEmote(ReactionEmote e) { + if(e==null)return "null"; + if(e.isEmoji())return e.getAsCodepoints(); + else return e.getId(); + } + + + } diff --git a/src/main/java/com/bernard/juliabot/Julia.java b/src/main/java/com/bernard/juliabot/Julia.java index 55af4ba..42cf0f1 100644 --- a/src/main/java/com/bernard/juliabot/Julia.java +++ b/src/main/java/com/bernard/juliabot/Julia.java @@ -1,9 +1,29 @@ package com.bernard.juliabot; -import java.io.*; -import java.lang.reflect.*; -import java.sql.*; -import java.util.*; +import java.io.BufferedReader; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; +import java.io.PrintStream; +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.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Properties; +import java.util.Scanner; +import java.util.Set; +import java.util.Timer; +import java.util.TimerTask; import java.util.jar.JarEntry; import java.util.jar.JarFile; import java.util.stream.Collectors; @@ -12,11 +32,15 @@ import org.apache.commons.io.output.TeeOutputStream; import com.bernard.juliabot.JuliaAddon.JarWithMultipleAddonsException; import com.bernard.juliabot.JuliaAddon.JuliaClassLoader; -import com.bernard.juliabot.api.*; +import com.bernard.juliabot.api.CCommande; +import com.bernard.juliabot.api.Command; +import com.bernard.juliabot.api.Discord; import com.thedeanda.lorem.LoremIpsum; -import net.dv8tion.jda.core.*; -import net.dv8tion.jda.core.events.Event; +import net.dv8tion.jda.api.JDA; +import net.dv8tion.jda.api.JDABuilder; +import net.dv8tion.jda.api.events.Event; +import net.dv8tion.jda.api.events.GenericEvent; public class Julia { @@ -24,20 +48,20 @@ public class Julia { public static final String sysinPipe = "/home/julia/entree"; - private static final String token = ""; + public static final String CONNECTION_DATA_FILEPATH = "/var/julia/julia.conn"; static Julia theJulia; - public JDA jda; + JDA jda; - Map avalivableAddons;//pkg+version->addon + Map avalivableAddons;// pkg+version->addon Map laboratoriesIdentifieurs;//Store channels IDs ... - public Map laboratoires; + Map laboratoires; Map fileTrack;// - public EcouteurDEvents lecouteur; + EcouteurDEvents lecouteur; ReadLoop sysinator; Connection eventDatabase; @@ -55,54 +79,77 @@ public class Julia { 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"); + + BufferedReader bis; try { - 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 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; + bis = new BufferedReader(new FileReader(CONNECTION_DATA_FILEPATH)); + String token = bis.readLine(); + + //Set up mysql cnnections (events & data) + Properties connectionProps = new Properties(); + connectionProps.put("user", bis.readLine()); + connectionProps.put("password", bis.readLine()); + connectionProps.put("serverTimezone", "UTC"); + connectionProps.put("verifyServerCertificate", "false"); + connectionProps.put("useSSL", "true"); + connectionProps.put("requireSSL", "true"); + String urlAndPort = bis.readLine(); + try { + eventDatabase = DriverManager.getConnection("jdbc:mysql://"+urlAndPort+"/juliaEvents", connectionProps); + juliaDatabase = DriverManager.getConnection("jdbc:mysql://"+urlAndPort+"/julia", connectionProps); + } 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(); + bis.close(); + return; + } + + System.out.println("La BDD est chargée" + eventDatabase+","+juliaDatabase); + + + // Démarrage de JDA et du Bot + try { + lecouteur = new EcouteurDEvents(this); + jda = JDABuilder.createDefault(token).addEventListeners(getLecouteur()).build(); + getJda().awaitReady(); + } catch(Exception e) { + System.err.println("Impossible de démarrer JuL'IA"); + e.printStackTrace(); + syserr.flush(); + bis.close(); + return; + } + + long guildHello = Long.parseLong(bis.readLine()); + long textChannelHello = Long.parseLong(bis.readLine()); + getJda().getGuildById(guildHello).getTextChannelById(textChannelHello).sendMessage(LoremIpsum.getInstance().getWords(10, 15)).complete(); + + long guildErr = Long.parseLong(bis.readLine()); + long textChannelErr = Long.parseLong(bis.readLine()); + + syserr = new JuliaErrPrintStream(getJda().getGuildById(guildErr).getTextChannelById(textChannelErr)); + + 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); + + bis.close(); + } catch (FileNotFoundException e1) { + System.err.println("Euhhhhh je n'ai pas trouvé le fichier "+CONNECTION_DATA_FILEPATH+" et je ne peux donc pas lire ma carte d'identitée"); + e1.printStackTrace(); + } catch (IOException e1) { + System.err.println("Euhhhhh je n'ai pas réussi à lire le fichier "+CONNECTION_DATA_FILEPATH+" et je ne peux donc pas lire ma carte d'identitée"); + e1.printStackTrace(); } - 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"); - 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 @@ -143,9 +190,9 @@ public class Julia { } 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)); + if(!getLaboratoires().containsKey(l.charAt(0))) + getLaboratoires().put(l.charAt(0), new Laboratory(l.charAt(0))); + Laboratory labo = getLaboratoires().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 } @@ -402,7 +449,7 @@ public class Julia { params[i] = Julia.this.juliaDatabase; break; case "net.dv8tion.jda.core.JDA": - params[i] = Julia.this.jda; + params[i] = Julia.this.getJda(); break; //TODO completer les paramètres @@ -426,8 +473,8 @@ public class Julia { } } - public void trigger(Event event) { - Class eventClass = event.getClass(); + public void trigger(GenericEvent event) { + Class eventClass = event.getClass(); Set toCall = loadedEvents.get(eventClass); for(Method m : toCall) { Object callable = callerObjects.get(m.getDeclaringClass()); @@ -541,5 +588,17 @@ public class Julia { public static Julia theJulia() { return theJulia; } + + public JDA getJda() { + return jda; + } + + public Map getLaboratoires() { + return laboratoires; + } + + public EcouteurDEvents getLecouteur() { + return lecouteur; + } } diff --git a/src/main/java/com/bernard/juliabot/JuliaAddon.java b/src/main/java/com/bernard/juliabot/JuliaAddon.java index 644c68b..99daf04 100644 --- a/src/main/java/com/bernard/juliabot/JuliaAddon.java +++ b/src/main/java/com/bernard/juliabot/JuliaAddon.java @@ -161,7 +161,7 @@ public class JuliaAddon { } } - //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<>();// @@ -227,7 +227,7 @@ public class JuliaAddon { 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 { @@ -248,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/JuliaErrPrintStream.java b/src/main/java/com/bernard/juliabot/JuliaErrPrintStream.java index e43f2a4..cc3e722 100644 --- a/src/main/java/com/bernard/juliabot/JuliaErrPrintStream.java +++ b/src/main/java/com/bernard/juliabot/JuliaErrPrintStream.java @@ -6,8 +6,8 @@ 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; +import net.dv8tion.jda.api.MessageBuilder; +import net.dv8tion.jda.api.entities.MessageChannel; public class JuliaErrPrintStream extends OutputStream { diff --git a/src/main/java/com/bernard/juliabot/api/DiscordCCommande.java b/src/main/java/com/bernard/juliabot/api/DiscordCCommande.java index 7d1dc94..21d1557 100644 --- a/src/main/java/com/bernard/juliabot/api/DiscordCCommande.java +++ b/src/main/java/com/bernard/juliabot/api/DiscordCCommande.java @@ -2,7 +2,10 @@ package com.bernard.juliabot.api; import java.time.OffsetDateTime; -import net.dv8tion.jda.core.entities.*; +import net.dv8tion.jda.api.JDA; +import net.dv8tion.jda.api.entities.Message; +import net.dv8tion.jda.api.entities.MessageChannel; +import net.dv8tion.jda.api.entities.User; public interface DiscordCCommande extends StringCCommande { @@ -12,6 +15,8 @@ public interface DiscordCCommande extends StringCCommande { public User getUser(); + public JDA getJDA(); + public String getContentStripped(); public OffsetDateTime getPostDate(); diff --git a/src/main/java/com/bernard/juliabot/api/JuLIAddon.java b/src/main/java/com/bernard/juliabot/api/JuLIAddon.java index 09554c5..968343b 100644 --- a/src/main/java/com/bernard/juliabot/api/JuLIAddon.java +++ b/src/main/java/com/bernard/juliabot/api/JuLIAddon.java @@ -11,9 +11,20 @@ import java.lang.annotation.Target; @Retention(RUNTIME) @Target(TYPE) public @interface JuLIAddon { + /** + * Le nom de l'addon + */ String name(); + /** + * La version de l'addon + */ String version() default ""; + /** + * Différentes classes, en plus de celle là, dans laquelle chercher des méthodes définissant des événements ou des commandes + */ Class[] searchPath() default {}; + /** + * La liste des personnes ayant dévellopé cet addon + */ public String[] devs(); - public boolean important() default false; } diff --git a/src/main/java/com/bernard/juliabot/api/Trukilie.java b/src/main/java/com/bernard/juliabot/api/Trukilie.java index 65d1401..5000dc3 100644 --- a/src/main/java/com/bernard/juliabot/api/Trukilie.java +++ b/src/main/java/com/bernard/juliabot/api/Trukilie.java @@ -4,12 +4,12 @@ import java.sql.Connection; import com.bernard.juliabot.Julia; -import net.dv8tion.jda.core.JDA; +import net.dv8tion.jda.api.JDA; public class Trukilie { public static JDA jda() { - return Julia.theJulia().jda; + return Julia.theJulia().getJda(); } public static Connection juliaDB() { diff --git a/src/main/java/com/bernard/juliabot/internaddon/Internaddon.java b/src/main/java/com/bernard/juliabot/internaddon/Internaddon.java index 8e3fe89..83446ca 100644 --- a/src/main/java/com/bernard/juliabot/internaddon/Internaddon.java +++ b/src/main/java/com/bernard/juliabot/internaddon/Internaddon.java @@ -22,12 +22,14 @@ import com.bernard.juliabot.api.JuLIAddon; import com.bernard.juliabot.api.StringCCommande; import com.thedeanda.lorem.LoremIpsum; -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; +import net.dv8tion.jda.api.JDA; +import net.dv8tion.jda.api.MessageBuilder; +import net.dv8tion.jda.api.entities.Message; +import net.dv8tion.jda.api.entities.MessageChannel; +import net.dv8tion.jda.api.entities.User; +import net.dv8tion.jda.api.events.message.MessageReceivedEvent; -@JuLIAddon(name="internaddon", devs = "Bernard", version="beta", important=true) +@JuLIAddon(name="internaddon", devs = "Bernard", version="beta") public class Internaddon { public static final String COMMANDEUR = "!!"; @@ -37,7 +39,7 @@ public class Internaddon { 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().getLaboratoires().get(Julia.theJulia().getLecouteur().getLabo(e));//Récupére le labo de l'évent InternalddonCCommande ccommande = new InternalddonCCommande(e,labo); try { CommandCalled called = labo.executeCommand(name, ccommande); @@ -133,6 +135,17 @@ public class Internaddon { } + @Command(name="guilds", description = "Liste les guildes disponibles",admin=true) + public void guilds(DiscordCCommande commande) { + MessageBuilder mb = new MessageBuilder(); + mb.append("Liste des serveurs :\n"); + Julia.theJulia().getJda().getGuilds() + .stream() + .map(g -> g.getName() + "(" + g.getMemberCount() + " membres, id:" + g.getId() + ")\n") + .forEach(mb::append);; + commande.getChannel().sendMessage(mb.build()).complete(); + } + @Command(name="update",description = "Met a jour le dossier des addons",admin=true) public void update(StringCCommande commande) { @@ -219,6 +232,11 @@ public class Internaddon { public User getUser() { return m.getAuthor(); } + + @Override + public JDA getJDA() { + return m.getJDA(); + } @Override public String getContentStripped() { @@ -227,13 +245,14 @@ public class Internaddon { @Override public OffsetDateTime getPostDate() { - return m.getCreationTime(); + return m.getTimeCreated(); } @Override public Laboratory getLabo() { return labo; } + } diff --git a/src/main/java/com/bernard/juliabot/internaddon/UnstableMessage.java b/src/main/java/com/bernard/juliabot/internaddon/UnstableMessage.java index 35a7b67..606b4d3 100644 --- a/src/main/java/com/bernard/juliabot/internaddon/UnstableMessage.java +++ b/src/main/java/com/bernard/juliabot/internaddon/UnstableMessage.java @@ -1,9 +1,10 @@ package com.bernard.juliabot.internaddon; -import java.io.*; +import java.io.IOException; +import java.io.OutputStream; import java.util.function.Consumer; -import net.dv8tion.jda.core.entities.Message; +import net.dv8tion.jda.api.entities.Message; public class UnstableMessage extends OutputStream{