Grundlage DB und Socketverbindung

src/main/java/DB/base.java

@@ -0,0 +1,96 @@
+package DB;
+
+import net.dv8tion.jda.core.JDA;
+
+import javax.security.auth.login.LoginException;
+import java.io.FileInputStream;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Properties;
+
+public  class base {
+
+
+    private Connection conn;
+    private String typ;
+    private String host;
+    private String port;
+    private String database;
+    private String name;
+    private String pw;
+
+
+
+
+    private boolean active;
+
+    protected base() {
+        FileInputStream input = null;
+        Properties config = new Properties();
+        active = true;
+
+        try {
+            input = new FileInputStream("shadowrun.cfg");
+            config.load(input);
+            if(!config.containsKey("db.typ")) {
+                active = false;
+            }
+
+            typ = config.getProperty("db.typ");
+            host = config.getProperty("db.host");
+            port = config.getProperty("db.port");
+            database = config.getProperty("db.database");
+            name = config.getProperty("db.name");
+            pw = config.getProperty("db.pw");
+
+            open();
+            close();
+            //rs.fetchSize;
+        }
+        catch (Exception e) {
+            active = false;
+        }
+    }
+
+    protected void open() {
+        if(!active)
+            return;
+        try {
+
+                conn = DriverManager.getConnection("jdbc:" + typ + "://" + host + ":" + port + "?useUnicode=true&characterEncoding=utf-8", name, pw);
+                ResultSet rs = conn.prepareStatement("SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = '" + database + "'").executeQuery();
+                rs.last();
+                if(rs.getRow() == 1) {
+                    conn.prepareStatement("use "+ database).executeQuery();
+                }
+        }
+        catch (SQLException e) {
+            active = false;
+            e.printStackTrace();
+        }
+    }
+
+    protected void close() {
+        if(!active)
+            return;
+        try {
+            if (!conn.isClosed())
+                conn.close();
+        }
+        catch (SQLException e) {
+            active = false;
+            e.printStackTrace();
+        }
+    }
+
+    protected boolean isActive() {
+        return active;
+    }
+
+    protected Connection getConn() {
+        return conn;
+    }
+}
+

src/main/java/Shadowrun/db_connect.java

@@ -0,0 +1,69 @@
+package Shadowrun;
+
+import java.sql.*;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class db_connect extends DB.base {
+
+    Connection conn;
+    public db_connect() {
+        if(!isActive())
+            return;
+        open();
+        try {
+            conn = getConn();
+            ResultSet rs = conn.prepareStatement("show tables like \"shadowrun_log\"").executeQuery();
+            while (rs.next()) {
+                String s = rs.getString(1);
+                System.out.println(s);
+            }
+        }
+        catch (SQLException e) {
+                e.printStackTrace();
+        }
+        close();
+    }
+
+    public void insertDice(String userName, String userId, String command, String result, String kanal) {
+        if(!isActive())
+            return;
+
+        open();
+        try {
+            conn = getConn();
+            String SQL_INSERT = "INSERT INTO shadowrun_log (benutzer, benutzerId, wurf, ergebnis, kanal) VALUES (?,?,?,?,?)";
+
+            PreparedStatement preparedStatement = conn.prepareStatement(SQL_INSERT);
+            preparedStatement.setString(1, userName);
+            preparedStatement.setString(2, userId);
+            preparedStatement.setString(3, command);
+            preparedStatement.setString(4, result);
+            preparedStatement.setString(5, kanal);
+            preparedStatement.executeUpdate();
+
+        }
+        catch (SQLException e) {
+            e.printStackTrace();
+        }
+        close();
+    }
+
+
+}
+
+/*
+ CREATE TABLE `shadowrun_log` (
+ `id` INT NOT NULL AUTO_INCREMENT,
+ `zeitstempel` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ `wurf` VARCHAR(255) NOT NULL DEFAULT '0',
+ `ergebnis`  VARCHAR(255) NOT NULL DEFAULT '0',
+ `benutzer` VARCHAR(255) NOT NULL DEFAULT '0',
+ `benutzerId` VARCHAR(255) NOT NULL DEFAULT '0',
+ `kanal` VARCHAR(50) NOT NULL DEFAULT '0',
+ PRIMARY KEY (`id`)
+ )
+ COLLATE='utf8_general_ci'
+ ;
+ */

src/main/java/Shadowrun/dice.java

@@ -30,6 +30,9 @@ public class dice extends ListenerAdapter {
 
     private language activLang;
 
+    private db_connect db;
+
+
     private Map<String, String> channelList = new HashMap<>();
 
 
@@ -38,6 +41,7 @@ public class dice extends ListenerAdapter {
         this.prefixIni = "/ini";
         this.prefixTest = "/rollTest";
         this.prefixZitat = "/zitat";
+        this.db = new db_connect();
     }
 
     @Override
@@ -289,7 +293,7 @@ public class dice extends ListenerAdapter {
             }
 
             event.getChannel().sendMessage(outputBox.build()).queue();
-
+            db.insertDice(event.getMember().getEffectiveName(), event.getMember().getUser().getId(),event.getMessage().getContentRaw(),result.toString().trim(), event.getChannel().getId());
         }
         catch (NumberFormatException e) {
             event.getChannel().sendMessage("Nope").queue();

src/main/java/Socket/shadowrun.java

@@ -0,0 +1,157 @@
+package Socket;
+
+import net.dv8tion.jda.core.EmbedBuilder;
+import net.dv8tion.jda.core.JDA;
+
+import java.awt.*;
+import java.io.*;
+import java.net.ServerSocket;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Scanner;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.net.Socket;
+
+
+public class shadowrun implements Runnable{
+
+    private JDA jda;
+
+    public shadowrun(JDA jda) {
+        this.jda = jda;
+    }
+
+    @Override
+    public void run()  {
+        int port = 11112;
+        try (ServerSocket listener = new ServerSocket(port)) {
+            System.out.println("Socket Server laeuft...");
+            ExecutorService pool = Executors.newFixedThreadPool(20);
+            while (true) {
+                pool.execute(new iniEcho(listener.accept(), jda));
+            }
+        }
+        catch (IOException e) {
+            System.err.println("Unable to process client request");
+            e.printStackTrace();
+        }
+
+    }
+
+
+    private static class iniEcho implements Runnable {
+        private Socket socket;
+        private JDA jda;
+
+        private boolean checkin;
+        private Scanner in;
+        private PrintWriter out;
+
+        private String salt;
+
+        iniEcho(Socket socket, JDA jda) {
+            this.socket = socket;
+            this.jda = jda;
+            this.checkin = false;
+            this.salt = "SamIstDerKoenigDerMatrix";
+        }
+
+        @Override
+        public void run() {
+            System.out.println("Connected: " + socket);
+            try {
+                in = new Scanner(socket.getInputStream());
+                out = new PrintWriter(socket.getOutputStream(), true);
+                String message = "";
+                while (in.hasNextLine()) {
+                    if(this.checkin == false) {
+                        chekin();
+                        continue;
+                    }
+                    message = in.nextLine().trim();
+                    switch (message) {
+                        case "get":
+                            break;
+                        case "send":
+                            send();
+                            break;
+                    }
+
+                    //out.println(message.toUpperCase() + "...");
+                    //jda.getGuildById("404979829537243148").getTextChannelById("542202034330271759").sendMessage(message).queue();
+                    //jda.getTextChannelById("542202034330271759").sendMessage(message).queue();
+                    //jda.sen
+                }
+            } catch (Exception e) {
+                System.out.println("Error:" + socket);
+            } finally {
+                try { socket.close(); } catch (IOException e) { e.printStackTrace(); }
+                System.out.println("Closed: " + socket);
+            }
+        }
+
+        /**
+         * bearbeitet Checkin
+         */
+        private void chekin() {
+            System.out.println("checkin");
+            String message = "";
+            message = in.nextLine().trim();
+            System.out.println(message);
+            if(message.startsWith("SRCheckin")) {
+                String[] msgParts = message.split("\\|", 3);
+                String Hash = getHash(msgParts[1] + salt);
+                System.out.println(msgParts[2].trim() + "  --  " + Hash);
+                if(msgParts[2].trim().equals(Hash)) {
+                    checkin = true;
+                    out.println("ACK");
+
+                }
+            }
+        }
+
+        /**
+         * Wandelt String in SHA-1 Hash um
+         * @param Input
+         * @return
+         */
+        private String getHash(String Input) {
+            try {
+                MessageDigest md = MessageDigest.getInstance("SHA-1");
+                md.update(salt.getBytes());
+                byte[] bytes = md.digest(Input.getBytes());
+                StringBuilder sb = new StringBuilder();
+                for(int i=0; i< bytes.length ;i++) {
+                    sb.append(Integer.toString((bytes[i] & 0xff) + 0x100, 16).substring(1));
+                }
+                return sb.toString();
+            }
+            catch (NoSuchAlgorithmException e) {
+                e.printStackTrace();
+            }
+            return "";
+        }
+
+        private void send() {
+            out.println("ACKSend");
+            String message;
+            EmbedBuilder outputBox = new EmbedBuilder();
+            outputBox.setColor(Color.BLACK);
+            outputBox.setTitle("Initiative:");
+
+            while (in.hasNextLine()) {
+                message = in.nextLine().trim();
+                if(message.trim().equals("FIN")) {
+                    break;
+                }
+                String[] msgParts = message.split("\\|",3);
+                //jda.getUserById(msgParts[0]).getName();
+
+                outputBox.addField( msgParts[0], msgParts[1], false);
+                out.println("ACKSend");
+            }
+            jda.getTextChannelById("542202034330271759").sendMessage(outputBox.build()).queue();
+        }
+    }
+}

src/main/java/core/Main.java

@@ -32,12 +32,13 @@ public class Main {
 
         try {
             JDA jda = builder.build();
+            Thread thread = new Thread(new Socket.shadowrun(jda));
+            thread.start();
+
         }
         catch (LoginException e) {
             e.printStackTrace();
         }
-
-
     }
 
 }