Initial commit

.gitignore

@@ -0,0 +1,118 @@
+# User-specific stuff
+.idea/
+
+*.iml
+*.ipr
+*.iws
+
+# IntelliJ
+out/
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+*~
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+# Windows thumbnail cache files
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+.gradle
+build/
+
+# Ignore Gradle GUI config
+gradle-app.setting
+
+# Cache of project
+.gradletasknamecache
+
+**/build/
+
+# Common working directory
+run/
+
+# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
+!gradle-wrapper.jar

build.gradle

@@ -0,0 +1,50 @@
+plugins {
+    id 'java'
+}
+
+group = 'xyz.tronax'
+version = '1.0'
+
+compileJava.options.encoding = "UTF-8"
+compileTestJava.options.encoding = "UTF-8"
+
+repositories {
+    mavenCentral()
+    maven {
+        name = "spigotmc-repo"
+        url = "https://hub.spigotmc.org/nexus/content/repositories/snapshots/"
+    }
+    maven {
+        name = "sonatype"
+        url = "https://oss.sonatype.org/content/groups/public/"
+    }
+}
+
+dependencies {
+    compileOnly "org.spigotmc:spigot-api:1.20.4-R0.1-SNAPSHOT"
+}
+
+def targetJavaVersion = 17
+java {
+    def javaVersion = JavaVersion.toVersion(targetJavaVersion)
+    sourceCompatibility = javaVersion
+    targetCompatibility = javaVersion
+    if (JavaVersion.current() < javaVersion) {
+        toolchain.languageVersion = JavaLanguageVersion.of(targetJavaVersion)
+    }
+}
+
+tasks.withType(JavaCompile).configureEach {
+    if (targetJavaVersion >= 10 || JavaVersion.current().isJava10Compatible()) {
+        options.release.set(targetJavaVersion)
+    }
+}
+
+processResources {
+    def props = [version: version]
+    inputs.properties props
+    filteringCharset 'UTF-8'
+    filesMatching('plugin.yml') {
+        expand props
+    }
+}

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1 @@
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.1.1-bin.zip

settings.gradle

@@ -0,0 +1 @@
+rootProject.name = 'ZalmikBan'

src/main/java/xyz/tronax/zalmikban/Main.java

@@ -0,0 +1,48 @@
+package xyz.tronax.zalmikban;
+
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.java.JavaPlugin;
+import xyz.tronax.zalmikban.commands.BanCommands;
+import xyz.tronax.zalmikban.listeners.JoinListener;
+import xyz.tronax.zalmikban.listeners.PlayerLogin;
+import xyz.tronax.zalmikban.mysql.MySQL;
+import xyz.tronax.zalmikban.util.FileManager;
+
+public final class Main extends JavaPlugin {
+
+    public void onEnable() {
+        instance = this;
+        register();
+        FileManager.setStandardConfig();
+        FileManager.setStandardMySQL();
+        FileManager.readConfig();
+        FileManager.readMySQL();
+        MySQL.connect();
+        MySQL.createTable();
+        Bukkit.getConsoleSender().sendMessage(prefix + " §aErfolgreich geladen!");
+
+    }
+
+    public void onDisable() {
+        Bukkit.getConsoleSender().sendMessage(prefix + " §cErfolgreich entladen!");
+        MySQL.close();
+    }
+
+    public void register() {
+        BanCommands banCMD = new BanCommands(this);
+        getCommand("ban").setExecutor(banCMD);
+        getCommand("tempban").setExecutor(banCMD);
+        getCommand("unban").setExecutor(banCMD);
+        getCommand("check").setExecutor(banCMD);
+
+        this.getServer().getPluginManager().registerEvents(new JoinListener(), this);
+        this.getServer().getPluginManager().registerEvents(new PlayerLogin(), this);
+    }
+
+    public String prefix;
+    public static Main instance;
+
+    public static Main getInstance() {
+        return instance;
+    }
+}

src/main/java/xyz/tronax/zalmikban/commands/BanCommands.java

@@ -0,0 +1,159 @@
+package xyz.tronax.zalmikban.commands;
+
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import xyz.tronax.zalmikban.Main;
+import xyz.tronax.zalmikban.mysql.MySQL;
+import xyz.tronax.zalmikban.util.BanManager;
+import xyz.tronax.zalmikban.util.BanUnit;
+
+import java.util.List;
+
+public class BanCommands implements CommandExecutor {
+
+    private Main plugin;
+
+    public BanCommands(Main plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
+
+        //Ban CMD
+        if(cmd.getName().equalsIgnoreCase("ban")) {
+            if(args.length >= 2) {
+                String playername = args[0];
+                if(BanManager.isBanned(getUUID(playername))) {
+                    sender.sendMessage(plugin.prefix + "§cDieser Spieler ist bereits gebannt!");
+                    return  true;
+                }
+                String reason = "";
+                for(int i = 1; i < args.length; i++) {
+                    reason += args[i] + " ";
+                }
+                BanManager.ban(getUUID(playername), playername, reason, -1);
+                sender.sendMessage(plugin.prefix + "§7Du hast §e" + playername + " §4§lPERMANENT §7gebannt!");
+                return true;
+
+            }
+            sender.sendMessage(plugin.prefix + "§c/ban <Spieler> <Grund>");
+            return true;
+        }
+        //
+
+        // Tempban CMD
+        if(cmd.getName().equalsIgnoreCase("tempban")) {
+            if(args.length >= 4) {
+                String playername = args[0];
+                if(BanManager.isBanned(getUUID(playername))) {
+                    sender.sendMessage(plugin.prefix + "§cDieser Spieler ist bereits gebannt!");
+                    return  true;
+                }
+                long value;
+                try {
+                    value = Integer.valueOf(args[1]);
+                } catch(NumberFormatException e) {
+                    sender.sendMessage(plugin.prefix + "§c<Zahlenwert> muss eine Zahl sein!");
+                    return true;
+                }
+                if(value >= 500) {
+                    sender.sendMessage(plugin.prefix + "§cDie Zahl muss unter 500 liegen!");
+                    return true;
+                }
+
+                String unitString = args[2];
+                String reason = "";
+                for(int i = 3; i < args.length; i++) {
+                    reason += args[i] + " ";
+                }
+                List<String> unitList = BanUnit.getUnitsAsString();
+                if(unitList.contains(unitString.toLowerCase())) {
+                    BanUnit unit = BanUnit.getUnit(unitString);
+                    long seconds = value * unit.getToSecond();
+                    //seconds++;
+                    sender.sendMessage(plugin.prefix + "§7Du hast §e"+playername+" §7für §c"+ value + unit.getName() + " §7gebannt!");
+                    BanManager.ban(getUUID(playername), playername, reason, seconds);
+
+                    return true;
+                }
+                sender.sendMessage(plugin.prefix + "§cDiese <Einheit> existiert nicht!");
+                return true;
+            }
+            sender.sendMessage(plugin.prefix + "§c/tempban <Spieler> <Zahlenwert> <Einheit> <Grund>");
+            return true;
+        }
+        //
+
+
+        //Check CMD
+        if(cmd.getName().equalsIgnoreCase("check")) {
+            if(args.length == 1) {
+                if(args[0].equalsIgnoreCase("list")) {
+                    List<String> list = BanManager.getBannedPlayers();
+                    if(list.size() == 0) {
+                        sender.sendMessage(plugin.prefix + "§cEs sind aktuell keine Spieler gebannt!");
+                        return true;
+                    }
+                    sender.sendMessage(plugin.prefix + "§7---------- §6§lBan-Liste §7----------");
+                    for(String allBanned : BanManager.getBannedPlayers()) {
+                        sender.sendMessage(plugin.prefix +"§e"+ allBanned + " §7(Grund: §r" + BanManager.getReason(getUUID(allBanned)) + "§7)");
+                    }
+                    return true;
+                }
+                String playername = args[0];
+                sender.sendMessage(plugin.prefix + "§7---------- §6§lBan-Infos §7----------");
+                sender.sendMessage(plugin.prefix + "§eName: §r" + playername);
+                sender.sendMessage(plugin.prefix + "§eGebannt: §r" + (BanManager.isBanned(getUUID(playername)) ? "§aJa!" : "§cNein!"));
+                if(BanManager.isBanned(getUUID(playername))) {
+                    sender.sendMessage(plugin.prefix + "§eGrund: §r" + BanManager.getReason(getUUID(playername)));
+                    sender.sendMessage(plugin.prefix + "§rVerbleibende Zeit: §r" + BanManager.getRemainingTime(getUUID(playername)));
+                }
+
+                return true;
+            }
+            sender.sendMessage(plugin.prefix + "§c/check (list) <Spieler>");
+            return true;
+        }
+        //
+
+        // Unban CMD
+        if(cmd.getName().equalsIgnoreCase("unban")) {
+            if(args.length == 1) {
+                String playername = args[0];
+                if(!BanManager.isBanned(getUUID(playername))) {
+                    sender.sendMessage(plugin.prefix + "§cDieser Spieler ist nicht gebannt!");
+                    return true;
+                }
+                BanManager.unban(getUUID(playername));
+                sender.sendMessage(plugin.prefix + "§7Du hast §e"+ playername + " §7entbannt!");
+                return true;
+            }
+            return true;
+        }
+
+        // Reconnect CMD
+        if(cmd.getName().equalsIgnoreCase("banreconnect")) {
+            if(args.length == 0) {
+                if(!MySQL.isConnected()) {
+                    MySQL.connect();
+                }
+            } else {
+                sender.sendMessage(plugin.prefix + "§cToo many arguments!");
+            }
+
+        }
+
+
+
+        return true;
+    }
+
+    @SuppressWarnings("deprecation")
+    private String getUUID(String playername) {
+        return Bukkit.getOfflinePlayer(playername).getUniqueId().toString();
+    }
+
+}

src/main/java/xyz/tronax/zalmikban/listeners/JoinListener.java

@@ -0,0 +1,17 @@
+package xyz.tronax.zalmikban.listeners;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import xyz.tronax.zalmikban.util.BanManager;
+
+public class JoinListener implements Listener {
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent e) {
+        Player p = e.getPlayer();
+        if(BanManager.isBanned(p.getUniqueId().toString())) {
+            BanManager.unban(p.getUniqueId().toString());
+        }
+    }
+}

src/main/java/xyz/tronax/zalmikban/listeners/PlayerLogin.java

@@ -0,0 +1,27 @@
+package xyz.tronax.zalmikban.listeners;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerLoginEvent;
+import xyz.tronax.zalmikban.util.BanManager;
+
+public class PlayerLogin implements Listener {
+    @EventHandler
+    public void onPlayerLogin(PlayerLoginEvent e) {
+        Player p = e.getPlayer();
+        if(BanManager.isBanned(p.getUniqueId().toString())) {
+            long current = System.currentTimeMillis();
+            long end = BanManager.getEnd(p.getUniqueId().toString());
+            if(current < end | end == -1) {
+                e.disallow(PlayerLoginEvent.Result.KICK_BANNED, "§cDu wurdest vom Server gebannt!\n"
+                        + "\n"
+                        + "§3Grund: §e" + BanManager.getReason(p.getUniqueId().toString()) + "\n"
+                        + "\n"
+                        + "§3Verbleibende Zeit: §e" + BanManager.getRemainingTime(p.getUniqueId().toString()));
+            }
+
+        }
+
+    }
+}

src/main/java/xyz/tronax/zalmikban/mysql/MySQL.java

@@ -0,0 +1,85 @@
+package xyz.tronax.zalmikban.mysql;
+
+import org.bukkit.Bukkit;
+import xyz.tronax.zalmikban.Main;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class MySQL {
+
+    public static String username;
+    public static String password;
+    public static String database;
+    public static String host;
+    public static String port;
+    public static Connection con;
+
+    public static void connect() {
+        if(!isConnected()) {
+            try {
+                con = DriverManager.getConnection("jdbc:mysql://" + host + ":" + port + "/" + database, username, password);
+                Bukkit.getConsoleSender().sendMessage(Main.getInstance().prefix + "MySQL Verbindung aufgebaut!");
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public static void close() {
+        if(isConnected()) {
+            try {
+                con.close();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+            Bukkit.getConsoleSender().sendMessage(Main.getInstance().prefix + "MySQL Verbindung getrennt!");
+        }
+    }
+
+    public static boolean isConnected() {
+        return con != null;
+    }
+
+    public static void createTable() {
+        /*
+         *
+         * Syntax: Spielername, UUID, Ende, Grund
+         *
+         *
+         */
+
+        if(isConnected()) {
+            try {
+                con.createStatement().executeUpdate("CREATE TABLE IF NOT EXISTS BannedPlayers (Spielername VARCHAR(100), UUID VARCHAR(100), Ende VARCHAR(100), Grund VARCHAR(100))");
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        }
+
+    }
+
+    public static void update(String qry) {
+        if(isConnected()) {
+            try {
+                con.createStatement().executeUpdate(qry);
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public static ResultSet getResult(String qry) {
+        if(isConnected()) {
+            try {
+                return con.createStatement().executeQuery(qry);
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        }
+        return null;
+    }
+
+}

src/main/java/xyz/tronax/zalmikban/util/BanManager.java

@@ -0,0 +1,121 @@
+package xyz.tronax.zalmikban.util;
+
+import org.bukkit.Bukkit;
+import xyz.tronax.zalmikban.mysql.MySQL;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class BanManager {
+
+    public static void ban(String uuid, String playername, String reason, long seconds) {
+        long end = 0;
+        if(seconds == -1) {
+            end = -1;
+        } else {
+            long current = System.currentTimeMillis();
+            long millis = seconds*1000;
+            end = current+millis;
+        }
+        MySQL.update("INSERT INTO BannedPlayers (Spielername, UUID, Ende, Grund)"
+                + " VALUES ('"+playername+"','"+uuid+"',"+end+",'"+reason+"')");
+        if(Bukkit.getPlayer(playername) != null) {
+            Bukkit.getPlayer(playername).kickPlayer("§cDu wurdest vom Server gebannt!\n"
+                    + "\n"
+                    + "§3Grund: §e" + getReason(uuid) + "\n"
+                    + "\n"
+                    + "§3Verbleibende Zeit: §e" + getRemainingTime(uuid));
+        }
+    }
+
+    public static void unban(String uuid) {
+        MySQL.update("DELETE FROM BannedPlayers WHERE UUID='"+uuid+"'");
+    }
+
+    public static boolean isBanned(String uuid) {
+        ResultSet rs = MySQL.getResult("SELECT Ende FROM BannedPlayers WHERE UUID='"+uuid+"'");
+        try {
+            return rs.next();
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+        return false;
+    }
+
+    public static String getReason(String uuid) {
+        ResultSet rs = MySQL.getResult("SELECT * FROM BannedPlayers WHERE UUID='"+uuid+"'");
+        try {
+            while(rs.next()) {
+                return rs.getString("Grund");
+            }
+        } catch(SQLException e) {
+            e.printStackTrace();
+        }
+        return "";
+    }
+
+    public static Long getEnd(String uuid) {
+        ResultSet rs = MySQL.getResult("SELECT * FROM BannedPlayers WHERE UUID='"+uuid+"'");
+        try {
+            while(rs.next()) {
+                return rs.getLong("Ende");
+            }
+        } catch(SQLException e) {
+            e.printStackTrace();
+        }
+        return (long) 0;
+    }
+
+    public static List<String> getBannedPlayers() {
+        List<String> list = new ArrayList<String>();
+        ResultSet rs = MySQL.getResult("SELECT * FROM BannedPlayers");
+        try {
+            while(rs.next()) {
+                list.add(rs.getString("Spielername"));
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+        return list;
+
+    }
+
+    public static String getRemainingTime(String uuid) {
+        long current = System.currentTimeMillis();
+        long end = getEnd(uuid);
+        if(end == -1) {
+            return "§4§lPERMANENT";
+        }
+        long millis = end - current;
+
+        long seconds = 1;
+        long minutes = 0;
+        long hours = 0;
+        long days = 0;
+        long weeks = 0;
+        while(millis >= 1000) {
+            millis-=1000;
+            seconds++;
+        }
+        while(seconds >= 60) {
+            seconds-=60;
+            minutes++;
+        }
+        while(minutes >= 60) {
+            minutes-=60;
+            hours++;
+        }
+        while(hours >= 24) {
+            hours-= 24;
+            days++;
+        }
+        while(days >= 7) {
+            days-=7;
+            weeks++;
+        }
+        return "§e" + weeks + " Woche(n) " + days + " Tag(e) " + hours + " Stunde(n) " + minutes + " Minute(n) " + seconds + " Sekunde(n) ";
+    }
+
+}

src/main/java/xyz/tronax/zalmikban/util/BanUnit.java

@@ -0,0 +1,53 @@
+package xyz.tronax.zalmikban.util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public enum BanUnit {
+
+    SECOND("Sekunde(n)", 1, "sec"),
+    MINUTE("Minute(n)", 60, "min"),
+    HOUR("Stunde(n)", 60*60, "hour"),
+    DAY("Tag(e)", 24*60*60, "day"),
+    WEEK("Woche(n)", 7*24*60*60, "week");
+
+    private String name;
+    private long toSecond;
+    private String shortcut;
+
+    private BanUnit(String name, long toSecond, String shortcut) {
+        this.name = name;
+        this.toSecond = toSecond;
+        this.shortcut = shortcut;
+    }
+
+    public long getToSecond() {
+        return toSecond;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getShortcut() {
+        return shortcut;
+    }
+
+    public static List<String> getUnitsAsString() {
+        List<String> units = new ArrayList<String>();
+        for(BanUnit unit : BanUnit.values()) {
+            units.add(unit.getShortcut().toLowerCase());
+        }
+        return units;
+    }
+
+    public static BanUnit getUnit(String unit) {
+        for(BanUnit units : BanUnit.values()) {
+            if(units.getShortcut().toLowerCase().equals(unit.toLowerCase())) {
+                return units;
+            }
+        }
+        return null;
+    }
+
+}

src/main/java/xyz/tronax/zalmikban/util/FileManager.java

@@ -0,0 +1,64 @@
+package xyz.tronax.zalmikban.util;
+
+import org.bukkit.ChatColor;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import xyz.tronax.zalmikban.Main;
+import xyz.tronax.zalmikban.mysql.MySQL;
+
+import java.io.File;
+import java.io.IOException;
+
+public class FileManager {
+
+    public static File getConfigFile() {
+        return new File("plugins/ZalmikBans", "config.yml");
+    }
+
+    public static FileConfiguration getConfigFileConfiguration() {
+        return YamlConfiguration.loadConfiguration(getConfigFile());
+    }
+
+    public static File getMySQLFile() {
+        return new File("plugins/ZalmikBans", "mysql.yml");
+    }
+
+    public static FileConfiguration getMySQLFileConfiguration() {
+        return YamlConfiguration.loadConfiguration(getMySQLFile());
+    }
+
+    public static void setStandardConfig() {
+        FileConfiguration cfg = getConfigFileConfiguration();
+        cfg.options().copyDefaults(true);
+        cfg.addDefault("prefix", "&8[&6Zalmik&3Ban&8]");
+
+        try {cfg.save(getConfigFile());} catch (IOException e) {e.printStackTrace();}
+    }
+
+    public static void readConfig() {
+        FileConfiguration cfg = getConfigFileConfiguration();
+        Main.getInstance().prefix = ChatColor.translateAlternateColorCodes('&', cfg.getString("prefix") + " §r");
+
+    }
+
+    public static void setStandardMySQL() {
+        FileConfiguration cfg = getMySQLFileConfiguration();
+        cfg.options().copyDefaults(true);
+        cfg.addDefault("username", "root");
+        cfg.addDefault("password", "password");
+        cfg.addDefault("database", "localhost");
+        cfg.addDefault("host", "localhost");
+        cfg.addDefault("port", "3306");
+        try {cfg.save(getMySQLFile());} catch (IOException e) {e.printStackTrace();}
+    }
+
+    public static void readMySQL() {
+        FileConfiguration cfg = getMySQLFileConfiguration();
+        MySQL.username = cfg.getString("username");
+        MySQL.password = cfg.getString("password");
+        MySQL.database = cfg.getString("database");
+        MySQL.host = cfg.getString("host");
+        MySQL.port = cfg.getString("port");
+    }
+
+}

src/main/resources/plugin.yml

@@ -0,0 +1,23 @@
+name: ZalmikBan
+version: '${version}'
+main: xyz.tronax.zalmikban.Main
+api-version: '1.20'
+authors: [Tronax]
+description: Ban Plugin für Zalmik.de
+website: https://tronax.xyz
+commands:
+  ban:
+    description: Bannt einen Spieler permanent!
+    permission: zalmikban.ban
+  tempban:
+    description: Bannt einen Spieler fuer eine bestimmte Zeit!
+    permission: zalmikban.tempban
+  unban:
+    description: Entbannt einen Spieler!
+    permission: zalmikban.unban
+  check:
+    description: Ueberprueft, ob ein Spieler gebannt ist!
+    permission: zalmikban.check
+  banreconnect:
+    description: Verbindet erneut zu der Datenbank!
+    permission: zalmikban.reconnect