.gitignore

@@ -22,11 +22,10 @@
 # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
 hs_err_pid*
 
+# IDE Files
 .idea/
-
-.settings/
-
 .vscode/
+.settings/
 
 config.json
 

pom.xml

@@ -52,6 +52,11 @@
       <artifactId>slf4j-simple</artifactId>
       <version>1.7.29</version>
     </dependency>
+    <dependency>
+      <groupId>club.minnced</groupId>
+      <artifactId>discord-webhooks</artifactId>
+      <version>0.1.8</version>
+    </dependency>
   </dependencies>
 
   <repositories>

src/main/java/com/bbn/hadder/Hadder.java

@@ -66,13 +66,16 @@ public class Hadder {
                         new BoobsCommand(),
                         new FeetCommand(),
                         new EroticCommand(),
-                        new RoleCommand()), config);
-       
+                        new RoleCommand(),
+                        new RulesCommand(),
+                        new LinkCommand()), config);
+
         builder.addEventListeners(
                 new MentionListener(rethink),
                 new PrivateMessageListener(),
                 new CommandListener(rethink, commandHandler),
                 new GuildListener(rethink, config),
+                new RulesListener(rethink),
                 new ReadyListener(rethink, config));
 
         try {

src/main/java/com/bbn/hadder/Rethink.java

@@ -54,14 +54,14 @@ public class Rethink {
         return new JSONArray();
     }
 
-    private String get(String table, String where, String value, String column) {
-        return this.getAsArray(table, where, value).getJSONObject(0).getString(column);
+    private Object get(String table, String where, String value, String column) {
+        return this.getAsArray(table, where, value).getJSONObject(0).get(column);
     }
 
-    private String update(String table, String whatvalue, String where, String wherevalue) {
+    private String update(String table, String wherevalue, String what, String whatvalue) {
         String out="";
         try {
-            Cursor cursor = r.table(table).get(whatvalue).update(r.hashMap(where, wherevalue)).run(conn);
+            Cursor cursor = r.table(table).get(wherevalue).update(r.hashMap(what, whatvalue)).run(conn);
             out=cursor.toString();
         } catch (ClassCastException ignored) {}
         return out;
@@ -100,7 +100,7 @@ public class Rethink {
     }
 
     public String getUserPrefix(String id) {
-        return this.get("user", "id", id, "prefix");
+        return (String) this.get("user", "id", id, "prefix");
     }
 
     public String setGuildPrefix(String prefix, String guildid) {
@@ -108,15 +108,56 @@ public class Rethink {
     }
 
     public String getGuildPrefix(String id) {
-        return this.get("server", "id", id, "prefix");
+        return (String) this.get("server", "id", id, "prefix");
+    }
+
+    public JSONArray getLinks(String id) {
+        return new JSONArray((String) this.get("server", "id", id, "links"));
+    }
+
+    public String addLinkedGuild(String guildid, String linkid) {
+        return this.update("server", guildid, "links", this.getLinks(guildid).put(linkid).toString());
+    }
+
+    public String removeLinkedGuild(String guildid, String linkid) {
+        JSONArray linkedguildslist = this.getLinks(guildid);
+        for (int i = 0; linkedguildslist.length()>i; i++) {
+            if (linkedguildslist.getString(i).equals(linkid)) {
+                linkedguildslist.remove(i);
+                break;
+            }
+        }
+        return this.update("server", guildid, "links", linkedguildslist.toString());
+    }
+
+    public String setLinkChannel(String guildid, String channelid) {
+        return this.update("server", guildid, "linkchannel", channelid);
+    }
+
+    public String getLinkChannel(String guildid) {
+        return (String) this.get("server", "id", guildid, "linkchannel");
     }
 
     public String insertGuild(String id) {
-        return this.insert("server", r.hashMap("id", id).with("prefix", "h."));
+        return this.insert("server", r.hashMap("id", id).with("prefix", "h.").with("links", "[]").with("linkchannel", "").with("message_id", "").with("role_id", ""));
     }
 
     public String insertUser(String id) {
         return this.insert("user", r.hashMap("id", id).with("prefix", "h."));
     }
 
+    public String updateRules(String guild_id, String message_id, String role_id) {
+        this.update("server", guild_id, "message_id", message_id);
+        this.update("server", guild_id, "role_id", role_id);
+        return null;
+    }
+
+    public String getRulesMID(String guild_id) {
+        return (String) this.get("server", "id", guild_id, "message_id");
+    }
+
+    public String getRulesRID(String guild_id) {
+        return (String) this.get("server", "id", guild_id, "role_id");
+    }
+
 }

src/main/java/com/bbn/hadder/commands/moderation/LinkCommand.java

@@ -0,0 +1,97 @@
+package com.bbn.hadder.commands.moderation;
+
+import com.bbn.hadder.commands.Command;
+import com.bbn.hadder.commands.CommandEvent;
+import com.bbn.hadder.core.LinkUtils;
+import com.bbn.hadder.utils.MessageEditor;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.MessageBuilder;
+import net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.MessageReaction;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class LinkCommand implements Command {
+    @Override
+    public void executed(String[] args, CommandEvent event) {
+        if (args.length == 0) return;
+        switch (args[0]) {
+
+            case "add":
+                if (args.length != 2) return;
+                String linkid = args[1];
+
+                // Check if guild is existing
+                boolean found = false;
+                Guild linkguild = null;
+                for (Guild g : event.getJDA().getGuilds()) {
+                    if (g.getId().equals(linkid)) {
+                        found = true;
+                        linkguild = g;
+                    }
+                }
+                // TODO
+                if (!found) return;
+
+                // Check if the guild is the same
+                if (event.getGuild().getId().equals(args[1])) {
+                    event.getChannel().sendMessage(
+                            new MessageEditor().setDefaultSettings(MessageEditor.MessageType.ERROR,
+                                    new EmbedBuilder().setTitle("Wait thats illegal.").setDescription("You specified the same guild as the guild on which you're reading this")).build()).queue();
+                    return;
+                }
+
+                // Send poll to all connected guilds
+                if (event.getRethink().getLinks(event.getGuild().getId()).length() > 0) {
+                    List<String> reactions = new ArrayList<>();
+                    reactions.addAll(Arrays.asList("✅", "❌"));
+                    new LinkUtils().sendAll(
+                            event.getRethink().getLinks(event.getGuild().getId()), event.getJDA(),
+                            new MessageBuilder()
+                                    .setEmbed(
+                                            new MessageEditor().setDefaultSettings(MessageEditor.MessageType.INFO,
+                                                    new EmbedBuilder()
+                                                            .setTitle(event.getGuild().getName() + " (" + event.getGuild().getId() + ") wants to add " + linkguild.getName() + " (" + linkguild.getId() + ")")
+                                                            .setDescription("Please vote if the Guild should be added.")).build()).build(),
+                            event.getJDA().getSelfUser(), reactions);
+                } else {
+                    Guild finalLinkguild = linkguild;
+                    new Thread(() -> {
+                        if (event.getRethink().getLinkChannel(linkid).isEmpty()) {
+                            event.getRethink().setLinkChannel(linkid, finalLinkguild.createTextChannel("linkchannel").complete().getId());
+                        }
+                        // Send Request to link Guild
+                        event.getJDA().getTextChannelById(event.getRethink().getLinkChannel(linkid)).sendMessage(
+                                new MessageEditor().setDefaultSettings(MessageEditor.MessageType.INFO,
+                                        new EmbedBuilder().setTitle(event.getGuild().getName() + " (" + event.getGuild().getId() + ") wants to link guilds!")
+                                                .setDescription("React with the reactions to accept or decline it")).build()
+                        ).queue(
+                                msg -> {
+                                    msg.addReaction("✅").queue();
+                                    msg.addReaction("❌").queue();
+                                }
+                        );
+                    }).start();
+                }
+
+                break;
+        }
+    }
+
+    @Override
+    public String[] labels() {
+        return new String[]{"link"};
+    }
+
+    @Override
+    public String description() {
+        return "Links two or more servers.";
+    }
+
+    @Override
+    public String usage() {
+        return "";
+    }
+}

src/main/java/com/bbn/hadder/commands/moderation/RulesCommand.java

@@ -0,0 +1,85 @@
+package com.bbn.hadder.commands.moderation;
+
+/*
+ * @author Skidder / GregTCLTK
+ */
+
+import com.bbn.hadder.commands.Command;
+import com.bbn.hadder.commands.CommandEvent;
+import com.bbn.hadder.utils.EventWaiter;
+import com.bbn.hadder.utils.MessageEditor;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.Permission;
+import net.dv8tion.jda.api.entities.Message;
+
+public class RulesCommand implements Command {
+
+    @Override
+    public void executed(String[] args, CommandEvent event) {
+        if (event.getMember().hasPermission(Permission.MANAGE_SERVER)) {
+            if (event.getGuild().getSelfMember().hasPermission(Permission.MANAGE_ROLES)) {
+                event.getTextChannel().sendMessage(new MessageEditor().setDefaultSettings(MessageEditor.MessageType.INFO, new EmbedBuilder()
+                        .setTitle("Rules setup")
+                        .setDescription("Please mention the channel în which I should send the rules. This should look like #rules."))
+                        .build()).queue();
+
+                new EventWaiter().newOnMessageEventWaiter(msgevent -> {
+                    if (msgevent.getMessage().getMentionedChannels().size() > 0) {
+                        msgevent.getChannel().sendMessage(new MessageEditor().setDefaultSettings(MessageEditor.MessageType.INFO, new EmbedBuilder()
+                                .setTitle("Rules")
+                                .setDescription("Now please send me the rules."))
+                                .build()).queue();
+                        new EventWaiter().newOnMessageEventWaiter(msgevent2 -> {
+                            msgevent2.getChannel().sendMessage(new MessageEditor().setDefaultSettings(MessageEditor.MessageType.INFO, new EmbedBuilder()
+                                    .setTitle("Role to assign"))
+                                    .setDescription("Now please send me the name of the role which the user will get after he accepted the rules.")
+                                    .build()).queue();
+                            new EventWaiter().newOnMessageEventWaiter(msgevent3 -> {
+                                try {
+                                    msgevent3.getGuild().getRolesByName(msgevent3.getMessage().getContentRaw(), false).get(0);
+                                    msgevent3.getChannel().sendMessage(new MessageEditor().setDefaultSettings(MessageEditor.MessageType.INFO, new EmbedBuilder().setTitle("Successfully set the rules")).build()).queue();
+                                    Message rules = msgevent.getMessage().getMentionedChannels().get(0).sendMessage(new MessageEditor().setDefaultSettings(MessageEditor.MessageType.INFO, new EmbedBuilder()
+                                            .setTitle("Rules"))
+                                            .setDescription(msgevent2.getMessage().getContentDisplay())
+                                            .build()).complete();
+                                    rules.addReaction("✅").queue();
+                                    rules.addReaction("❌").queue();
+
+                                    event.getRethink().updateRules(event.getGuild().getId(), rules.getId(), msgevent3.getGuild().getRolesByName(msgevent3.getMessage().getContentRaw(), false).get(0).getId());
+                                } catch (Exception e) {
+                                    e.printStackTrace();
+                                }
+                            }, event.getJDA(), event.getAuthor());
+                        }, event.getJDA(), event.getAuthor());
+                    } else {
+                        event.getTextChannel().sendMessage(new MessageEditor().setDefaultSettings(MessageEditor.MessageType.WARNING, new EmbedBuilder()
+                                .setTitle("No Channel mentioned"))
+                                .setDescription("Please mention a channel. This should look like #rules")
+                                .build()).queue();
+                    }
+                    }, event.getJDA(), event.getAuthor());
+            } else {
+                EmbedBuilder builder = new EmbedBuilder();
+                event.getTextChannel().sendMessage(new MessageEditor().setDefaultSettings(MessageEditor.MessageType.NO_SELF_PERMISSION, builder).build()).queue();
+            }
+        } else {
+            EmbedBuilder builder = new EmbedBuilder();
+            event.getTextChannel().sendMessage(new MessageEditor().setDefaultSettings(MessageEditor.MessageType.NO_PERMISSION, builder).build()).queue();
+        }
+    }
+
+    @Override
+    public String[] labels() {
+        return new String[]{"rules"};
+    }
+
+    @Override
+    public String description() {
+        return "Setup the rules on your Discord server";
+    }
+
+    @Override
+    public String usage() {
+        return "";
+    }
+}

src/main/java/com/bbn/hadder/commands/owner/TestCommand.java

@@ -2,9 +2,6 @@ package com.bbn.hadder.commands.owner;
 
 import com.bbn.hadder.commands.Command;
 import com.bbn.hadder.commands.CommandEvent;
-import net.dv8tion.jda.api.entities.Activity;
-
-import java.util.Arrays;
 
 /*
  * @author Skidder / GregTCLTK

src/main/java/com/bbn/hadder/core/LinkUtils.java

@@ -0,0 +1,88 @@
+package com.bbn.hadder.core;
+
+import club.minnced.discord.webhook.WebhookClient;
+import club.minnced.discord.webhook.WebhookClientBuilder;
+import club.minnced.discord.webhook.send.WebhookEmbed;
+import club.minnced.discord.webhook.send.WebhookEmbedBuilder;
+import club.minnced.discord.webhook.send.WebhookMessageBuilder;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.entities.*;
+import org.json.JSONArray;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+
+public class LinkUtils {
+
+    public void sendAll(JSONArray jsonArray, JDA jda, Message message, User user, List<String> reactions) {
+        for (int i = 0; jsonArray.length() > i; i++) {
+            this.send(message, jda.getTextChannelById(jsonArray.getString(i)), user, reactions);
+        }
+    }
+
+    private void send(Message message, TextChannel channel, User user, List<String> reactions) {
+
+        channel.retrieveWebhooks().queue(
+                webhooks -> {
+                    Webhook webhook=null;
+                    for (Webhook webhooktemp : webhooks) {
+                        if (webhooktemp.getOwner().equals(channel.getJDA().getSelfUser())) {
+                            webhook=webhooktemp;
+                        }
+                    }
+
+                    if (webhook==null) {
+                        channel.createWebhook("Hadder GuildLink").queue(
+                                webhook1 -> sendMessage(webhook1, channel, user, message, reactions)
+                        );
+                    } else sendMessage(webhook, channel, user, message, reactions);
+                }
+        );
+
+
+    }
+
+    private void sendMessage(Webhook webhook, TextChannel channel, User user, Message message, List<String> reactions) {
+        WebhookClientBuilder builder = new WebhookClientBuilder(webhook.getId());
+        WebhookClient client = builder.build();
+        WebhookMessageBuilder mb = new WebhookMessageBuilder();
+        mb.setUsername(user.getName())
+                .setAvatarUrl((user.getAvatarUrl()!=null) ? user.getAvatarUrl() : user.getDefaultAvatarUrl())
+                .setContent(message.getContentRaw());
+        for (Message.Attachment attachment:message.getAttachments()) {
+            try {
+                mb.addFile(attachment.getFileName(), attachment.retrieveInputStream().get());
+            } catch (InterruptedException | ExecutionException e) {
+                e.printStackTrace();
+            }
+        }
+        for (MessageEmbed embed : message.getEmbeds()) {
+            List<WebhookEmbed.EmbedField> fields = new ArrayList<>();
+            for (MessageEmbed.Field field : embed.getFields()) {
+                fields.add(new WebhookEmbed.EmbedField(field.isInline(), field.getName(), field.getValue()));
+            }
+            mb.addEmbeds(new WebhookEmbed(
+                    embed.getTimestamp(), embed.getColorRaw(), embed.getDescription(),
+                    embed.getThumbnail().getUrl(), embed.getImage().getUrl(), new WebhookEmbed.EmbedFooter(embed.getFooter().getText(), embed.getFooter().getIconUrl()),
+                    new WebhookEmbed.EmbedTitle(embed.getTitle(), embed.getUrl()),
+                    new WebhookEmbed.EmbedAuthor(embed.getAuthor().getName(), embed.getAuthor().getIconUrl(), embed.getAuthor().getUrl()), fields));
+        }
+        try {
+            long msgid = client.send(mb.build()).get().getId();
+            channel.retrieveMessageById(msgid).queue(
+                    msg -> {
+                        for (String reaction: reactions) {
+                            msg.addReaction(reaction).queue();
+                        }
+                    }
+            );
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } catch (ExecutionException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

src/main/java/com/bbn/hadder/listener/LinkListener.java

@@ -0,0 +1,27 @@
+package com.bbn.hadder.listener;
+
+import com.bbn.hadder.Rethink;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+import net.dv8tion.jda.api.events.message.react.MessageReactionAddEvent;
+import net.dv8tion.jda.api.hooks.ListenerAdapter;
+
+import javax.annotation.Nonnull;
+
+public class LinkListener extends ListenerAdapter {
+
+    Rethink rethink;
+
+    public LinkListener(Rethink rethink) {
+        this.rethink = rethink;
+    }
+
+    @Override
+    public void onMessageReactionAdd(@Nonnull MessageReactionAddEvent event) {
+
+    }
+
+    @Override
+    public void onMessageReceived(@Nonnull MessageReceivedEvent event) {
+        // TODO
+    }
+}

src/main/java/com/bbn/hadder/listener/RulesListener.java

@@ -0,0 +1,25 @@
+package com.bbn.hadder.listener;
+
+/*
+ * @author Skidder / GregTCLTK
+ */
+
+import com.bbn.hadder.Rethink;
+import net.dv8tion.jda.api.events.message.react.MessageReactionAddEvent;
+import net.dv8tion.jda.api.hooks.ListenerAdapter;
+
+public class RulesListener extends ListenerAdapter {
+
+    private Rethink rethink;
+
+    public RulesListener(Rethink rethink) {
+        this.rethink = rethink;
+    }
+
+    @Override
+    public void onMessageReactionAdd(MessageReactionAddEvent event) {
+        if (event.getMessageId().equals(rethink.getRulesMID(event.getGuild().getId()))) {
+            event.getGuild().addRoleToMember(event.getMember(), event.getGuild().getRoleById(rethink.getRulesRID(event.getGuild().getId()))).queue();
+        }
+    }
+}