Starting...

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/config/BauServer.java

@@ -36,7 +36,7 @@ public class BauServer {
     private Integer owner;
 
     public UUID getOwner() {
-        return SteamwarUser.get(getOwnerID()).getUUID();
+        return SteamwarUser.byId(getOwnerID()).getUUID();
     }
 
     public int getOwnerID() {

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/bau/InfoCommand.java

@@ -47,7 +47,7 @@ public class InfoCommand extends SWCommand {
 
     @Register(description = "BAU_INFO_COMMAND_HELP")
     public void genericCommand(Player p) {
-        BauSystem.MESSAGE.send("BAU_INFO_COMMAND_OWNER", p, SteamwarUser.get(bauServer.getOwnerID()).getUserName());
+        BauSystem.MESSAGE.send("BAU_INFO_COMMAND_OWNER", p, SteamwarUser.byId(bauServer.getOwnerID()).getUserName());
         Region region = Region.getRegion(p.getLocation());
         for (Flag flag : Flag.getFlags()) {
             if (!region.getFlags().has(flag).isApplicable()) continue;
@@ -97,7 +97,7 @@ public class InfoCommand extends SWCommand {
                 st.append("§8, ");
             }
             st.append("§7");
-            st.append(SteamwarUser.get(bauweltMembers.get(i).getMemberID()).getUserName());
+            st.append(SteamwarUser.byId(bauweltMembers.get(i).getMemberID()).getUserName());
         }
         return st.toString();
     }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/region/TestblockCommand.java

@@ -31,7 +31,6 @@ import de.steamwar.command.SWCommand;
 import de.steamwar.command.TypeMapper;
 import de.steamwar.linkage.Linked;
 import de.steamwar.linkage.LinkedInstance;
-import de.steamwar.sql.BauweltMember;
 import de.steamwar.sql.Punishment;
 import de.steamwar.sql.SchematicNode;
 import de.steamwar.sql.SteamwarUser;
@@ -198,7 +197,7 @@ public class TestblockCommand extends SWCommand {
             @Override
             public List<String> tabCompletes(CommandSender commandSender, PreviousArguments previousArguments, String s) {
                 List<String> stringList = new ArrayList<>(SchematicNode.getNodeTabcomplete(SteamwarUser.get(((Player) commandSender).getUniqueId()), s));
-                stringList.addAll(SchematicNode.getNodeTabcomplete(SteamwarUser.get(0), s));
+                stringList.addAll(SchematicNode.getNodeTabcomplete(SteamwarUser.byId(0), s));
                 return stringList;
             }
 
@@ -206,7 +205,7 @@ public class TestblockCommand extends SWCommand {
             public SchematicNode map(CommandSender commandSender, PreviousArguments previousArguments, String s) {
                 SchematicNode node = SchematicNode.getNodeFromPath(SteamwarUser.get(((Player) commandSender).getUniqueId()), s);
                 if (node == null) {
-                    node = SchematicNode.getNodeFromPath(SteamwarUser.get(0), s);
+                    node = SchematicNode.getNodeFromPath(SteamwarUser.byId(0), s);
                 }
                 return node;
             }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/script/ScriptHelper.java

@@ -38,7 +38,7 @@ public class ScriptHelper {
         BookMeta meta = (BookMeta) itemStack.getItemMeta();
         if(!writeable) {
             meta.setTitle(script.getName());
-            meta.setAuthor(SteamwarUser.get(script.getUserId()).getUserName());
+            meta.setAuthor(SteamwarUser.byId(script.getUserId()).getUserName());
         }
         meta.setPages(getScriptPages(script));
         itemStack.setItemMeta(meta);

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/script/lua/libs/StorageLib.java

@@ -89,7 +89,7 @@ public class StorageLib implements LuaLib, Enable, Disable {
                 jsonObject.keySet().forEach(key -> {
                     map.put(key, fromJson(jsonObject.get(key)));
                 });
-                SteamwarUser steamwarUser = SteamwarUser.get(Integer.parseInt(playerStorage.getName().substring(0, playerStorage.getName().length() - ".json".length())));
+                SteamwarUser steamwarUser = SteamwarUser.byId(Integer.parseInt(playerStorage.getName().substring(0, playerStorage.getName().length() - ".json".length())));
                 PLAYER_STORAGE.put(steamwarUser.getUUID(), map);
             } catch (Exception e) {}
         }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/simulator/storage/YAPIONFormatSimulatorLoader.java

@@ -54,7 +54,7 @@ public class YAPIONFormatSimulatorLoader implements SimulatorLoader {
         }
 
         String name = file.getName().substring(0, file.getName().length() - 7);
-        SteamwarUser steamwarUser = SteamwarUser.get(Integer.parseInt(name));
+        SteamwarUser steamwarUser = SteamwarUser.byId(Integer.parseInt(name));
 
         List<Simulator> simulators = new ArrayList<>();
         for (String s : yapionObject.getKeys()) {

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/world/AntiBauAddMemberFix.java

@@ -41,7 +41,7 @@ public class AntiBauAddMemberFix implements Listener {
         }
         if (BauweltMember.getBauMember(BauServer.getInstance().getOwner(), event.getPlayer().getUniqueId()) == null) {
             event.getPlayer().kickPlayer("");
-            throw new SecurityException("The player " + event.getPlayer().getName() + " joined on the server of " + SteamwarUser.get(BauServer.getInstance().getOwnerID()).getUserName() + " without being added!");
+            throw new SecurityException("The player " + event.getPlayer().getName() + " joined on the server of " + SteamwarUser.byId(BauServer.getInstance().getOwnerID()).getUserName() + " without being added!");
         }
     }
 

CommonCore/SQL/build.gradle.kts

@@ -19,10 +19,51 @@
 
 plugins {
     steamwar.java
+    kotlin("jvm")
+}
+
+kotlin {
+    jvmToolchain(8)
+}
+
+sourceSets {
+    main {
+        java {
+            srcDirs("src/")
+            exclude("**/*.kt")
+        }
+        kotlin {
+            srcDirs("src/")
+            exclude("**/*.java")
+        }
+        resources {
+            srcDirs("src/")
+            exclude("**/*.java", "**/*.kt")
+        }
+    }
+    test {
+        java {
+            srcDirs("testsrc/")
+            exclude("**/*.kt")
+        }
+        kotlin {
+            srcDirs("testsrc/")
+            exclude("**/*.java")
+        }
+        resources {
+            srcDirs("testsrc/")
+            exclude("**/*.java", "**/*.kt")
+        }
+    }
 }
 
 dependencies {
     compileOnly(libs.sqlite)
 
     implementation("org.yaml:snakeyaml:2.2")
+
+    api(libs.exposedCore)
+    api(libs.exposedDao)
+    api(libs.exposedJdbc)
+    api(libs.exposedTime)
 }

CommonCore/SQL/src/de/steamwar/sql/AuditLog.kt

@@ -17,109 +17,105 @@
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package de.steamwar.sql;
+package de.steamwar.sql
 
-import de.steamwar.sql.internal.Field;
+import de.steamwar.sql.internal.useDb
-import de.steamwar.sql.internal.SqlTypeMapper;
+import org.jetbrains.exposed.v1.core.dao.id.EntityID
-import de.steamwar.sql.internal.Statement;
+import org.jetbrains.exposed.v1.core.dao.id.IntIdTable
-import de.steamwar.sql.internal.Table;
+import org.jetbrains.exposed.v1.dao.IntEntity
-import lombok.AllArgsConstructor;
+import org.jetbrains.exposed.v1.dao.IntEntityClass
-import lombok.Getter;
+import org.jetbrains.exposed.v1.javatime.timestamp
-import lombok.NonNull;
+import java.time.Instant
 
-import java.sql.Timestamp;
+object AuditLogTable: IntIdTable("AuditLog", "AuditLogId") {
-import java.time.Instant;
+    val time = timestamp("Time")
+    val server = varchar("ServerName", 255)
+    val serverOwner = integer("ServerOwner").nullable()
+    val actor = integer("Actor")
+    val action = enumerationByName("ActionType", 255, AuditLog.Type::class)
+    val actionText = text("ActionText")
+}
 
-@AllArgsConstructor
+class AuditLog(id: EntityID<Int>): IntEntity(id) {
-public class AuditLog {
+    companion object: IntEntityClass<AuditLog>(AuditLogTable) {
+        const val SERVER_NAME_VELOCITY: String = "Velocity"
 
-    static {
+        private fun create(
-        SqlTypeMapper.nameEnumMapper(AuditLog.Type.class);
+            serverName: String,
+            serverOwner: SteamwarUser?,
+            actor: SteamwarUser,
+            actionType: Type,
+            text: String = ""
+        ) = useDb {
+            new {
+                this.time = Instant.now()
+                this.server = serverName
+                this.serverOwner = serverOwner?.id?.value
+                this.actor = actor.id.value
+                this.action = actionType
+                this.actionText = text
+            }
+        }
+
+        @JvmStatic
+        fun createJoin(jointServerName: String, serverOwner: SteamwarUser?, joinedPlayer: SteamwarUser) = create(jointServerName, serverOwner, joinedPlayer, Type.JOIN)
+
+        @JvmStatic
+        fun createLeave(leftServerName: String, serverOwner: SteamwarUser?, joinedPlayer: SteamwarUser) = create(leftServerName, serverOwner, joinedPlayer, Type.LEAVE)
+
+        @JvmStatic
+        fun createCommand(serverName: String, serverOwner: SteamwarUser?, player: SteamwarUser?, command: String) = player?.let { create(serverName, serverOwner, it, Type.COMMAND, command) }
+
+        @JvmStatic
+        fun createSensitiveCommand(
+            serverName: String,
+            serverOwner: SteamwarUser?,
+            player: SteamwarUser?,
+            command: String
+        ) = player?.let { create(serverName, serverOwner, it, Type.SENSITIVE_COMMAND, command) }
+
+        @JvmStatic
+        fun createChat(serverName: String, serverOwner: SteamwarUser?, chatter: SteamwarUser, chat: String) = create(serverName, serverOwner, chatter, Type.CHAT, chat)
+
+        @JvmStatic
+        fun createGuiOpen(serverName: String, serverOwner: SteamwarUser?, player: SteamwarUser, guiName: String) = create(serverName, serverOwner, player, Type.GUI_OPEN, guiName)
+
+        @JvmStatic
+        fun createGuiClick(
+            serverName: String,
+            serverOwner: SteamwarUser?,
+            player: SteamwarUser,
+            guiName: String,
+            clickType: String,
+            slot: Int,
+            itemName: String
+        ) = create(
+            serverName,
+            serverOwner,
+            player,
+            Type.GUI_CLICK,
+            "Gui: $guiName\nSlot: $slot\nClickType: $clickType\nItemName: $itemName"
+        )
+
+        @JvmStatic
+        fun createGuiClose(serverName: String, serverOwner: SteamwarUser?, player: SteamwarUser, guiName: String) = create(serverName, serverOwner, player, Type.GUI_CLOSE, guiName)
     }
 
-    public static final String SERVER_NAME_VELOCITY = "Velocity";
+    var time by AuditLogTable.time
+    var server by AuditLogTable.server
+    var serverOwner by AuditLogTable.serverOwner
+    var actor by AuditLogTable.actor
+    var action by AuditLogTable.action
+    var actionText by AuditLogTable.actionText
 
-    private static final Table<AuditLog> table = new Table<>(AuditLog.class);
+    enum class Type {
-
-    private static final Statement create = table.insertFields(true, "time", "serverName", "serverOwner", "actor", "actionType", "actionText");
-
-    @Getter
-    @Field
-    private final Timestamp time;
-
-    @Getter
-    @Field
-    private final String serverName;
-
-    @Field(nullable = true)
-    private final int serverOwner;
-
-    @Field
-    private final int actor;
-
-    @Getter
-    @Field
-    private final Type actionType;
-
-    @Getter
-    @Field
-    private final String actionText;
-
-    public enum Type {
         JOIN,
         LEAVE,
         COMMAND,
         SENSITIVE_COMMAND,
-
         CHAT,
         GUI_OPEN,
         GUI_CLOSE,
         GUI_CLICK,
     }
-
+}
-    private static void create(String serverName, SteamwarUser serverOwner, SteamwarUser actor, Type actionType, String text) {
-        create.insertGetKey(Timestamp.from(Instant.now()), serverName, serverOwner, actor, actionType, text);
-    }
-
-    public static void createJoin(@NonNull String jointServerName, SteamwarUser serverOwner, @NonNull SteamwarUser joinedPlayer) {
-        create(jointServerName, serverOwner, joinedPlayer, Type.JOIN, "");
-    }
-
-    public static void createLeave(@NonNull String leftServerName, SteamwarUser serverOwner, @NonNull SteamwarUser joinedPlayer) {
-        create(leftServerName, serverOwner, joinedPlayer, Type.LEAVE, "");
-    }
-
-    public static void createCommand(@NonNull String serverName, SteamwarUser serverOwner, SteamwarUser player, @NonNull String command) {
-        if (player == null) return;
-        create(serverName, serverOwner, player, Type.COMMAND, command);
-    }
-
-    public static void createSensitiveCommand(@NonNull String serverName, SteamwarUser serverOwner, SteamwarUser player, @NonNull String command) {
-        if (player == null) return;
-        create(serverName, serverOwner, player, Type.SENSITIVE_COMMAND, command);
-    }
-
-    public static void createChat(@NonNull String serverName, SteamwarUser serverOwner, @NonNull SteamwarUser chatter, @NonNull String chat) {
-        create(serverName, serverOwner, chatter, Type.CHAT, chat);
-    }
-
-    public static void createGuiOpen(@NonNull String serverName, SteamwarUser serverOwner, @NonNull SteamwarUser player, @NonNull String guiName) {
-        create(serverName, serverOwner, player, Type.GUI_OPEN, guiName);
-    }
-
-    public static void createGuiClick(@NonNull String serverName, SteamwarUser serverOwner, @NonNull SteamwarUser player, @NonNull String guiName, @NonNull String clickType, int slot, @NonNull String itemName) {
-        create(serverName, serverOwner, player, Type.GUI_CLICK, "Gui: " + guiName + "\nSlot: " + slot + "\nClickType: " + clickType + "\nItemName: " + itemName);
-    }
-
-    public static void createGuiClose(@NonNull String serverName, SteamwarUser serverOwner, @NonNull SteamwarUser player, @NonNull String guiName) {
-        create(serverName, serverOwner, player, Type.GUI_CLOSE, guiName);
-    }
-
-    public SteamwarUser getServerOwner() {
-        return SteamwarUser.get(serverOwner);
-    }
-
-    public SteamwarUser getActor() {
-        return SteamwarUser.get(actor);
-    }
-}

CommonCore/SQL/src/de/steamwar/sql/BannedUserIPs.kt

@@ -17,51 +17,62 @@
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package de.steamwar.sql;
+package de.steamwar.sql
 
-import de.steamwar.sql.internal.Field;
+import de.steamwar.sql.internal.useDb
-import de.steamwar.sql.internal.SelectStatement;
+import org.jetbrains.exposed.v1.core.dao.id.CompositeID
-import de.steamwar.sql.internal.Statement;
+import org.jetbrains.exposed.v1.core.dao.id.CompositeIdTable
-import de.steamwar.sql.internal.Table;
+import org.jetbrains.exposed.v1.core.dao.id.EntityID
-import lombok.AllArgsConstructor;
+import org.jetbrains.exposed.v1.core.eq
-import lombok.Getter;
+import org.jetbrains.exposed.v1.dao.CompositeEntity
+import org.jetbrains.exposed.v1.dao.CompositeEntityClass
+import org.jetbrains.exposed.v1.javatime.timestamp
+import org.jetbrains.exposed.v1.jdbc.deleteWhere
+import org.jetbrains.exposed.v1.jdbc.insertIgnore
+import java.sql.Timestamp
+import java.time.Instant
 
-import java.sql.Timestamp;
+object BannedUserIPsTable: CompositeIdTable("BannedUserIPs") {
-import java.time.Instant;
+    val userId = reference("UserID", SteamwarUserTable)
-import java.util.List;
+    val timestamp = timestamp("Timestamp")
+    val ip = varchar("IP", 45)
 
-@AllArgsConstructor
+    override val primaryKey = PrimaryKey(userId, ip)
-public class BannedUserIPs {
-
-    private static final Table<BannedUserIPs> table = new Table<>(BannedUserIPs.class);
-
-    private static final SelectStatement<BannedUserIPs> getByID = table.selectFields("UserID");
-    private static final SelectStatement<BannedUserIPs> getByIP = new SelectStatement<>(table, "SELECT * FROM BannedUserIPs WHERE IP = ? ORDER BY Timestamp DESC");
-    private static final Statement banIP = table.insertAll();
-    private static final Statement unbanIPs = table.deleteFields("UserID");
-
-    @Getter
-    @Field(keys = {Table.PRIMARY})
-    private final int userID;
-    @Getter
-    @Field(def = "CURRENT_TIMESTAMP")
-    private final Timestamp timestamp;
-    @Field(keys = {Table.PRIMARY})
-    private final String ip;
-
-    public static List<BannedUserIPs> get(int userID) {
-        return getByID.listSelect(userID);
-    }
-
-    public static List<BannedUserIPs> get(String ip) {
-        return getByIP.listSelect(ip);
-    }
-
-    public static void banIP(int userID, String ip){
-        banIP.update(userID, Timestamp.from(Instant.now()), ip);
-    }
-
-    public static void unbanIPs(int userID) {
-        unbanIPs.update(userID);
-    }
 }
+
+class BannedUserIPs(id: EntityID<CompositeID>): CompositeEntity(id) {
+    companion object: CompositeEntityClass<BannedUserIPs>(BannedUserIPsTable) {
+
+        @JvmStatic
+        fun get(userId: Int) = useDb {
+            find { BannedUserIPsTable.userId eq userId }.toList()
+        }
+
+        @JvmStatic
+        fun get(ip: String) = useDb {
+            find { BannedUserIPsTable.ip eq ip }.toList()
+        }
+
+        @JvmStatic
+        fun banIP(userId: Int, ip: String) = useDb {
+            BannedUserIPsTable.insertIgnore {
+                it[BannedUserIPsTable.userId] = userId
+                it[BannedUserIPsTable.ip] = ip
+                it[BannedUserIPsTable.timestamp] = Instant.now()
+            }
+        }
+
+        @JvmStatic
+        fun unbanIPs(userId: Int) = useDb {
+            BannedUserIPsTable.deleteWhere { BannedUserIPsTable.userId eq userId }
+        }
+    }
+
+    val userID by BannedUserIPsTable.userId.transform({ EntityID(it, SteamwarUserTable) }, { it.value })
+    val timestamp: Timestamp by BannedUserIPsTable.timestamp.transform({ it.toInstant() }, { Timestamp.from(it) })
+    val ip by BannedUserIPsTable.ip
+
+    fun remove() = useDb {
+        delete()
+    }
+}

CommonCore/SQL/src/de/steamwar/sql/BauweltMember.kt

@@ -17,107 +17,109 @@
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package de.steamwar.sql;
+package de.steamwar.sql
 
-import de.steamwar.sql.internal.Field;
+import de.steamwar.sql.BauweltMemberTable.bauweltId
-import de.steamwar.sql.internal.SelectStatement;
+import de.steamwar.sql.internal.useDb
-import de.steamwar.sql.internal.Statement;
+import org.jetbrains.exposed.v1.core.and
-import de.steamwar.sql.internal.Table;
+import org.jetbrains.exposed.v1.core.dao.id.CompositeID
-import lombok.Getter;
+import org.jetbrains.exposed.v1.core.dao.id.CompositeIdTable
+import org.jetbrains.exposed.v1.core.dao.id.EntityID
+import org.jetbrains.exposed.v1.core.eq
+import org.jetbrains.exposed.v1.dao.CompositeEntity
+import org.jetbrains.exposed.v1.dao.CompositeEntityClass
+import org.jetbrains.exposed.v1.jdbc.insertIgnore
+import java.util.UUID
 
-import java.util.*;
+object BauweltMemberTable: CompositeIdTable("BauweltMember") {
+    val bauweltId = reference("BauweltID", SteamwarUserTable)
+    val memberId = reference("MemberID", SteamwarUserTable)
+    val build = bool("Build")
+    val worldEdit = bool("WorldEdit")
+    val world = bool("World")
 
-public class BauweltMember {
+    override val primaryKey = PrimaryKey(bauweltId, memberId)
-    private static final Map<Integer, BauweltMember> memberCache = new HashMap<>();
-
-    public static void clear() {
-        memberCache.clear();
-    }
-
-    private static final Table<BauweltMember> table = new Table<>(BauweltMember.class);
-    private static final SelectStatement<BauweltMember> getMember = table.select(Table.PRIMARY);
-    private static final SelectStatement<BauweltMember> getMembers = table.selectFields("BauweltID");
-    private static final Statement update = table.insertAll();
-    private static final Statement delete = table.delete(Table.PRIMARY);
-
-    public static void addMember(UUID ownerID, UUID memberID) {
-        new BauweltMember(SteamwarUser.get(ownerID).getId(), SteamwarUser.get(memberID).getId(), false, false).updateDB();
-    }
-
-    public static BauweltMember getBauMember(UUID ownerID, UUID memberID){
-        return getBauMember(SteamwarUser.get(ownerID).getId(), SteamwarUser.get(memberID).getId());
-    }
-
-    public static BauweltMember getBauMember(int ownerID, int memberID){
-        BauweltMember member = memberCache.get(memberID);
-        if(member != null && member.bauweltID == ownerID)
-            return member;
-        return getMember.select(ownerID, memberID);
-    }
-
-    public static List<BauweltMember> getMembers(UUID bauweltID){
-        return getMembers(SteamwarUser.get(bauweltID).getId());
-    }
-
-    public static List<BauweltMember> getMembers(int bauweltID){
-        return getMembers.listSelect(bauweltID);
-    }
-
-    @Getter
-    @Field(keys = {Table.PRIMARY})
-    private final int bauweltID;
-    @Getter
-    @Field(keys = {Table.PRIMARY})
-    private final int memberID;
-    @Getter
-    @Field(def = "0")
-    private boolean worldEdit;
-    @Getter
-    @Field(def = "0")
-    private boolean world;
-
-    public BauweltMember(int bauweltID, int memberID, boolean worldEdit, boolean world) {
-        this.bauweltID = bauweltID;
-        this.memberID = memberID;
-        this.worldEdit = worldEdit;
-        this.world = world;
-        memberCache.put(memberID, this);
-    }
-
-    public void setWorldEdit(boolean worldEdit) {
-        this.worldEdit = worldEdit;
-        updateDB();
-    }
-
-    public void setWorld(boolean world) {
-        this.world = world;
-        updateDB();
-    }
-
-    private void updateDB(){
-        update.update(bauweltID, memberID, worldEdit, world);
-    }
-
-    public void remove(){
-        delete.update(bauweltID, memberID);
-        memberCache.remove(memberID);
-    }
-
-    public boolean isBuild() {
-        return worldEdit;
-    }
-
-    public boolean isSupervisor() {
-        return world;
-    }
-
-    public void setBuild(boolean build) {
-        this.worldEdit = build;
-        updateDB();
-    }
-
-    public void setSupervisor(boolean supervisor) {
-        this.world = supervisor;
-        updateDB();
-    }
 }
+
+class BauweltMember(id: EntityID<CompositeID>): CompositeEntity(id) {
+    companion object: CompositeEntityClass<BauweltMember>(BauweltMemberTable) {
+        private val cache = mutableMapOf<Int, BauweltMember>()
+
+        private fun cache(member: BauweltMember) = cache.put(member.memberID, member)
+
+        @JvmStatic
+        fun clear() = cache.clear()
+
+        @JvmStatic
+        @Deprecated("Use addMember(ownerId: Int, newMemberId: Int)")
+        fun addMember(ownerId: UUID, newMemberId: UUID) = addMember(SteamwarUser.get(ownerId)!!.id, SteamwarUser.get(newMemberId)!!.id)
+
+        @JvmStatic
+        fun addMember(ownerId: Int, newMemberId: Int) = addMember(EntityID(ownerId, SteamwarUserTable), EntityID(newMemberId, SteamwarUserTable))
+
+        fun addMember(ownerId: EntityID<Int>, newMemberId: EntityID<Int>) = useDb {
+            BauweltMemberTable.insertIgnore {
+                it[bauweltId] = ownerId
+                it[memberId] = newMemberId
+                it[build] = false
+                it[worldEdit] = false
+                it[world] = false
+            }
+        }
+
+        @JvmStatic
+        @Deprecated("Use getBauMember(bauwelt: Int, member: Int)")
+        fun getBauMember(bauwelt: UUID, member: UUID) = useDb {
+            find { (bauweltId eq SteamwarUser.get(bauwelt)!!.id) and (BauweltMemberTable.memberId eq SteamwarUser.get(member)!!.id) }.firstOrNull()?.also { cache(it) }
+        }
+
+        @JvmStatic
+        fun getBauMember(bauwelt: Int, member: Int) = useDb {
+            find { (bauweltId eq bauwelt) and (BauweltMemberTable.memberId eq member) }.firstOrNull()?.also { cache(it) }
+        }
+
+        @JvmStatic
+        @Deprecated("Use getMembers(bauwelt: Int)")
+        fun getMembers(bauwelt: UUID) = getMembers(SteamwarUser.get(bauwelt)!!.id.value)
+
+        @JvmStatic
+        fun getMembers(bauwelt: Int) = useDb {
+            find { bauweltId eq bauwelt }.toList().also { it.forEach { cache(it) } }
+        }
+    }
+
+    val bauweltID by BauweltMemberTable.bauweltId.transform({ EntityID(it, SteamwarUserTable) }, { it.value })
+    val memberID by BauweltMemberTable.memberId.transform({ EntityID(it, SteamwarUserTable) }, { it.value })
+    private var worldEditInternal by BauweltMemberTable.worldEdit
+    var worldEdit: Boolean
+        get() = worldEditInternal
+        set(value) = useDb {
+            worldEditInternal = value
+        }
+    private var buildInternal by BauweltMemberTable.build
+    var build: Boolean
+        get() = buildInternal
+        set(value) = useDb {
+            buildInternal = value
+        }
+    private var worldInternal by BauweltMemberTable.world
+    var world: Boolean
+        get() = worldInternal
+        set(value) = useDb {
+            worldInternal = value
+        }
+    var supervisor: Boolean
+        get() = world
+        set(value) = useDb {
+            world = value
+        }
+
+    fun isBuild() = worldEdit
+    fun isSupervisor() = world
+    fun isWorldEdit() = build
+    fun isWorld() = world
+
+    fun remove() = useDb {
+        delete()
+    }
+}

CommonCore/SQL/src/de/steamwar/sql/Fight.java

@@ -105,11 +105,11 @@ public class Fight {
     }
 
     public SteamwarUser getBlueLeader() {
-        return SteamwarUser.get(blueLeader);
+        return SteamwarUser.byId(blueLeader);
     }
 
     public SteamwarUser getRedLeader() {
-        return SteamwarUser.get(redLeader);
+        return SteamwarUser.byId(redLeader);
     }
 
     public boolean replayAllowed() {

CommonCore/SQL/src/de/steamwar/sql/GameModeConfig.java

@@ -35,11 +35,19 @@ import java.util.stream.Collectors;
 public final class GameModeConfig<M, W> {
 
     public static final Function<String, String> ToString = Function.identity();
-    public static final Function<File, String> ToStaticWarGear = __ -> "WarGear";
+    public static final Function<File, String> ToStaticWarGear = GameModeConfig::constWarGear;
-    public static final Function<File, String> ToInternalName = file -> file.getName().replace(".yml", "");
+    public static final Function<File, String> ToInternalName = GameModeConfig::internalName;
     public static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("dd.MM.yyyy HH:mm");
     private static final Random random = new Random();
 
+    private static String constWarGear(File f) {
+        return "WarGear";
+    }
+
+    private static String internalName(File f) {
+        return f.getName().replace(".yml", "");
+    }
+
     private static final Map<String, GameModeConfig<?, String>> byFileName;
     private static final Map<String, GameModeConfig<?, String>> byGameName;
     private static final Map<SchematicType, GameModeConfig<?, String>> bySchematicType;

CommonCore/SQL/src/de/steamwar/sql/SchematicNode.java

@@ -242,11 +242,11 @@ public class SchematicNode {
 
     public static List<SchematicNode> getAccessibleSchematicsOfTypeInParent(int owner, String schemType,
             Integer parent) {
-        return accessibleByUserTypeParent(SteamwarUser.get(owner), SchematicType.fromDB(schemType), parent);
+        return accessibleByUserTypeParent(SteamwarUser.byId(owner), SchematicType.fromDB(schemType), parent);
     }
 
     public static List<SchematicNode> getAllAccessibleSchematicsOfType(int user, String schemType) {
-        return accessibleByUserType(SteamwarUser.get(user), SchematicType.fromDB(schemType));
+        return accessibleByUserType(SteamwarUser.byId(user), SchematicType.fromDB(schemType));
     }
 
     public static List<SchematicNode> getAllSchematicsOfType(int owner, String schemType) {
@@ -278,12 +278,12 @@ public class SchematicNode {
 
     @Deprecated
     public static List<SchematicNode> getSchematicsAccessibleByUser(int user, Integer parent) {
-        return list(SteamwarUser.get(user), parent);
+        return list(SteamwarUser.byId(user), parent);
     }
 
     @Deprecated
     public static List<SchematicNode> getAllSchematicsAccessibleByUser(int user) {
-        return getAll(SteamwarUser.get(user));
+        return getAll(SteamwarUser.byId(user));
     }
 
     public static List<SchematicNode> getAllParentsOfNode(SchematicNode node) {

CommonCore/SQL/src/de/steamwar/sql/SteamwarUser.kt

@@ -17,373 +17,273 @@
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package de.steamwar.sql;
+package de.steamwar.sql
 
-import de.steamwar.sql.internal.*;
+import de.steamwar.sql.internal.useDb
-import lombok.Getter;
+import org.jetbrains.exposed.v1.core.JoinType
+import org.jetbrains.exposed.v1.core.dao.id.EntityID
+import org.jetbrains.exposed.v1.core.dao.id.IntIdTable
+import org.jetbrains.exposed.v1.core.eq
+import org.jetbrains.exposed.v1.core.inList
+import org.jetbrains.exposed.v1.dao.IntEntity
+import org.jetbrains.exposed.v1.dao.IntEntityClass
+import org.jetbrains.exposed.v1.jdbc.insert
+import org.jetbrains.exposed.v1.jdbc.select
+import java.security.SecureRandom
+import java.sql.Timestamp
+import java.util.*
+import java.util.function.Consumer
+import javax.crypto.SecretKeyFactory
+import javax.crypto.spec.PBEKeySpec
 
-import javax.crypto.SecretKeyFactory;
+object SteamwarUserTable : IntIdTable("UserData", "id") {
-import javax.crypto.spec.PBEKeySpec;
+    val uuid = varchar("UUID", 36)
-import java.security.NoSuchAlgorithmException;
+    val username = varchar("UserName", 32)
-import java.security.SecureRandom;
+    val team = integer("Team")
-import java.security.spec.InvalidKeySpecException;
+    val leader = bool("Leader")
-import java.sql.Timestamp;
+    val locale = varchar("Locale", 16).nullable()
-import java.util.*;
+    val manualeLocale = bool("ManualeLocale")
-import java.util.function.Consumer;
+    val bedrock = bool("Bedrock")
-import java.util.logging.Level;
+    val password = text("Password").nullable()
-import java.util.stream.Collectors;
+    val discordId = long("DiscordId").nullable()
-import java.util.stream.Stream;
-
-public class SteamwarUser {
-    private static final SecureRandom random = new SecureRandom();
-    private static final SecretKeyFactory factory;
-
-	static {
-        try {
-            factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA512");
-        } catch (NoSuchAlgorithmException e) {
-            throw new SecurityException(e);
-        }
-
-        new SqlTypeMapper<>(UUID.class, "CHAR(36)", (rs, identifier) -> UUID.fromString(rs.getString(identifier)), (st, index, value) -> st.setString(index, value.toString()));
-		new SqlTypeMapper<>(Locale.class, "VARCHAR(32)", (rs, identifier) -> {
-			String l = rs.getString(identifier);
-			return l != null ? Locale.forLanguageTag(l) : null;
-		}, (st, index, value) -> st.setString(index, value.toLanguageTag()));
-		new SqlTypeMapper<>(SteamwarUser.class, null, (rs, identifier) -> { throw new SecurityException("SteamwarUser cannot be used as type (recursive select)"); }, (st, index, value) -> st.setInt(index, value.id));
-	}
-
-	private static final Table<SteamwarUser> table = new Table<>(SteamwarUser.class, "UserData");
-	private static final Statement insert = table.insertFields("UUID", "UserName");
-	private static final SelectStatement<SteamwarUser> byID = table.selectFields("id");
-	private static final SelectStatement<SteamwarUser> byUUID = table.selectFields("UUID");
-	private static final SelectStatement<SteamwarUser> byName = table.selectFields("UserName");
-	private static final SelectStatement<SteamwarUser> byDiscord = table.selectFields("DiscordId");
-	private static final SelectStatement<SteamwarUser> byTeam = table.selectFields("Team");
-	private static final SelectStatement<SteamwarUser> getUsersWithPerm = new SelectStatement<>(table, "SELECT S.* FROM UserData S JOIN UserPerm P ON S.id = P.User WHERE P.Perm = ?");
-	private static final SelectStatement<SteamwarUser> getAll = new SelectStatement<SteamwarUser>(table, "SELECT * FROM UserData");
-
-	private static final Statement updateName = table.update(Table.PRIMARY, "UserName");
-    private static final Statement updatePassword = table.update(Table.PRIMARY, "Password");
-	private static final Statement updateLocale = table.update(Table.PRIMARY, "Locale", "ManualLocale");
-	private static final Statement updateTeam = table.update(Table.PRIMARY, "Team");
-	private static final Statement updateLeader = table.update(Table.PRIMARY, "Leader");
-	private static final Statement updateDiscord = table.update(Table.PRIMARY, "DiscordId");
-
-	private static final Statement getPlaytime = new Statement("SELECT SUM(UNIX_TIMESTAMP(EndTime) - UNIX_TIMESTAMP(StartTime)) as Playtime FROM Session WHERE UserID = ?");
-	private static final Statement getFirstjoin = new Statement("SELECT MIN(StartTime) AS FirstJoin FROM Session WHERE UserID = ?");
-	private static final Statement getLastonline = new Statement("SELECT MAX(EndTime) AS LastOnline FROM Session WHERE UserID = ?");
-
-	private static final Map<Integer, SteamwarUser> usersById = new HashMap<>();
-	private static final Map<UUID, SteamwarUser> usersByUUID = new HashMap<>();
-	private static final Map<String, SteamwarUser> usersByName = new HashMap<>();
-	private static final Map<Long, SteamwarUser> usersByDiscord = new HashMap<>();
-	public static void clear() {
-		usersById.clear();
-		usersByName.clear();
-		usersByUUID.clear();
-		usersByDiscord.clear();
-	}
-
-	public static void invalidate(int userId) {
-		SteamwarUser user = usersById.remove(userId);
-		if (user == null)
-			return;
-		usersByName.remove(user.getUserName());
-		usersByUUID.remove(user.getUUID());
-		usersByDiscord.remove(user.getDiscordId());
-	}
-
-	public static SteamwarUser get(String userName){
-		SteamwarUser user = usersByName.get(userName.toLowerCase());
-		if(user != null)
-			return user;
-		return byName.select(userName);
-	}
-
-	public static SteamwarUser get(UUID uuid){
-		SteamwarUser user = usersByUUID.get(uuid);
-		if(user != null)
-			return user;
-		return byUUID.select(uuid);
-	}
-
-	public static SteamwarUser get(int id) {
-		SteamwarUser user = usersById.get(id);
-		if(user != null)
-			return user;
-		return byID.select(id);
-	}
-
-	public static SteamwarUser get(Long discordId) {
-		if(usersByDiscord.containsKey(discordId))
-			return usersByDiscord.get(discordId);
-		return byDiscord.select(discordId);
-	}
-
-	public static SteamwarUser getOrCreate(UUID uuid, String name, Consumer<UUID> newPlayer) {
-		SteamwarUser user = get(uuid);
-
-		if (user != null) {
-			if (!user.userName.equals(name)) {
-				updateName.update(name, user.id);
-				user.userName = name;
-			}
-
-			return user;
-		} else {
-			insert.update(uuid, name);
-			newPlayer.accept(uuid);
-			return get(uuid);
-		}
-	}
-
-	public static List<SteamwarUser> getUsersWithPerm(UserPerm userPerm) {
-		return getUsersWithPerm.listSelect(userPerm);
-	}
-
-    public static List<SteamwarUser> getServerTeam() {
-        return Stream.of(getUsersWithPerm(UserPerm.PREFIX_ADMIN),
-                        getUsersWithPerm(UserPerm.PREFIX_DEVELOPER),
-                        getUsersWithPerm(UserPerm.PREFIX_MODERATOR),
-                        getUsersWithPerm(UserPerm.PREFIX_SUPPORTER),
-                        getUsersWithPerm(UserPerm.PREFIX_BUILDER)
-                )
-                .flatMap(Collection::stream)
-                .collect(Collectors.toList());
-    }
-
-	public static List<SteamwarUser> getTeam(int teamId) {
-		return byTeam.listSelect(teamId);
-	}
-
-	public static void batchCache(Set<Integer> ids) {
-		ids.removeIf(usersById::containsKey);
-		if(ids.isEmpty())
-			return;
-
-		try (SelectStatement<SteamwarUser> batch = new SelectStatement<>(table, "SELECT * FROM UserData WHERE id IN (" + ids.stream().map(Object::toString).collect(Collectors.joining(", ")) + ")")) {
-			batch.listSelect();
-		}
-	}
-
-	@Getter
-	@Field(keys = {Table.PRIMARY}, autoincrement = true)
-	private final int id;
-	@Field(keys = {"uuid"})
-	private final UUID uuid;
-	@Getter
-	@Field
-	private String userName;
-    @Field(nullable = true)
-    private String password;
-    @Getter
-	@Field(def = "0")
-	private int team;
-	@Getter
-	@Field(def = "0")
-	private boolean leader;
-	@Field(nullable = true)
-	private Locale locale;
-	@Field(def = "0")
-	private boolean manualLocale;
-	@Getter
-	@Field(keys = {"discordId"}, nullable = true)
-	private Long discordId;
-
-	private Map<Punishment.PunishmentType, Punishment> punishments = null;
-	private Set<UserPerm> permissions = null;
-	private UserPerm.Prefix prefix = null;
-
-	public SteamwarUser(int id, UUID uuid, String userName, String password, int team, boolean leader, Locale locale, boolean manualLocale, Long discordId) {
-		this.id = id;
-		this.uuid = uuid;
-		this.userName = userName;
-        this.password = password;
-		this.team = team;
-		this.leader = leader;
-		this.locale = locale;
-		this.manualLocale = manualLocale;
-		this.discordId = discordId != null && discordId != 0 ? discordId : null;
-
-		usersById.put(id, this);
-		usersByName.put(userName.toLowerCase(), this);
-		usersByUUID.put(uuid, this);
-		if (this.discordId != null) {
-			usersByDiscord.put(discordId, this);
-		}
-	}
-
-	public UUID getUUID() {
-		return uuid;
-	}
-
-	public Locale getLocale() {
-		if(locale != null)
-			return locale;
-		return Locale.getDefault();
-	}
-
-	public Punishment getPunishment(Punishment.PunishmentType type) {
-		initPunishments();
-		return punishments.getOrDefault(type, null);
-	}
-
-	public boolean isPunished(Punishment.PunishmentType punishment) {
-		initPunishments();
-		if (!punishments.containsKey(punishment)) {
-			return false;
-		}
-		if (!punishments.get(punishment).isCurrent()) {
-			if (punishment == Punishment.PunishmentType.Ban) {
-				BannedUserIPs.unbanIPs(id);
-			}
-			punishments.remove(punishment);
-			return false;
-		}
-		return true;
-	}
-
-	public boolean hasPerm(UserPerm perm) {
-		initPerms();
-		return permissions.contains(perm);
-	}
-
-	public Set<UserPerm> perms() {
-		initPerms();
-		return permissions;
-	}
-
-	public UserPerm.Prefix prefix() {
-		initPerms();
-		return prefix;
-	}
-
-	public double getOnlinetime() {
-		return getPlaytime.select(rs -> {
-			if (rs.next() && rs.getBigDecimal("Playtime") != null)
-				return rs.getBigDecimal("Playtime").doubleValue();
-			return 0.0;
-		}, id);
-	}
-
-	public Timestamp getFirstjoin() {
-		return getFirstjoin.select(rs -> {
-			if (rs.next())
-				return rs.getTimestamp("FirstJoin");
-			return null;
-		}, id);
-	}
-
-	public Timestamp getLastOnline() {
-		return getLastonline.select(rs -> {
-			if (rs.next())
-				return rs.getTimestamp("LastOnline");
-			return null;
-		}, id);
-	}
-
-	public void punish(Punishment.PunishmentType punishment, Timestamp time, String banReason, int from, boolean perma) {
-		initPunishments();
-		punishments.remove(punishment);
-		punishments.put(punishment, Punishment.createPunishment(id, from, punishment, banReason, time, perma));
-	}
-
-	public void setTeam(int team) {
-		this.team = team;
-		updateTeam.update(team, id);
-		setLeader(false);
-	}
-
-	public void setLeader(boolean leader) {
-		this.leader = leader;
-		updateLeader.update(leader, id);
-	}
-
-	public void setLocale(Locale locale, boolean manualLocale) {
-		if (locale == null || (this.manualLocale && !manualLocale))
-			return;
-
-		this.locale = locale;
-		this.manualLocale = manualLocale;
-		updateLocale.update(locale.toLanguageTag(), manualLocale, id);
-	}
-
-	public void setDiscordId(Long discordId) {
-		usersByDiscord.remove(this.discordId);
-		this.discordId = discordId;
-		updateDiscord.update(discordId, id);
-		if (discordId != null) {
-			usersByDiscord.put(discordId, this);
-		}
-	}
-
-    public void setPassword(String password) {
-        try {
-            byte[] salt = new byte[16];
-            random.nextBytes(salt);
-            String saltString = Base64.getEncoder().encodeToString(salt);
-
-            byte[] hash = generateHash(password, salt);
-            String hashString = Base64.getEncoder().encodeToString(hash);
-            this.password = hashString + ":" + saltString;
-            updatePassword.update(this.password, id);
-        } catch (Exception e) {
-            throw new SecurityException(e);
-        }
-    }
-
-    public boolean verifyPassword(String password) {
-        try {
-            if (!hasPassword()) {
-                return false;
-            }
-
-            String[] parts = this.password.split(":");
-            if (parts.length != 2) {
-                SQLConfig.impl.getLogger().log(Level.SEVERE ,"Invalid password hash for user {0} ({1})", new Object[]{userName, id});
-                return false;
-            }
-
-            String hashString = parts[0];
-            byte[] realHash = Base64.getDecoder().decode(hashString);
-            String saltString = parts[1];
-            byte[] salt = Base64.getDecoder().decode(saltString);
-            byte[] hash = generateHash(password, salt);
-            return Arrays.equals(realHash, hash);
-        } catch (Exception e) {
-            SQLConfig.impl.getLogger().log(Level.SEVERE, "Error while verifying password for user " + userName + " (" + id + ")", e);
-            return false;
-        }
-    }
-
-	public boolean hasPassword() {
-		return this.password != null;
-	}
-
-    private byte[] generateHash(String password, byte[] salt)
-            throws InvalidKeySpecException {
-        PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 65536, 512);
-        return factory.generateSecret(spec).getEncoded();
-
-    }
-
-	private void initPunishments() {
-		if(punishments != null)
-			return;
-
-		punishments = Punishment.getPunishmentsOfPlayer(id);
-	}
-
-	private void initPerms() {
-		if(permissions != null)
-			return;
-
-		permissions = UserPerm.getPerms(id);
-		prefix = permissions.stream().filter(UserPerm.prefixes::containsKey).findAny().map(UserPerm.prefixes::get).orElse(UserPerm.emptyPrefix);
-	}
-
-    public static List<SteamwarUser> getAll() {
-        return getAll.listSelect();
-    }
 }
+
+class SteamwarUser(id: EntityID<Int>): IntEntity(id) {
+    companion object: IntEntityClass<SteamwarUser>(SteamwarUserTable) {
+        private val random = SecureRandom()
+        private val factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA512")
+
+        private val byId = mutableMapOf<Int, SteamwarUser>()
+        private val byUUID = mutableMapOf<UUID, SteamwarUser>()
+        private val byDiscordId = mutableMapOf<Long, SteamwarUser>()
+        private val byUsername = mutableMapOf<String, SteamwarUser>()
+
+        @JvmStatic
+        fun clear() {
+            byId.clear()
+            byUUID.clear()
+            byDiscordId.clear()
+            byUsername.clear()
+        }
+
+        @JvmStatic
+        fun invalidate(userId: Int) {
+            val user = byId.remove(userId)
+            if(user != null) {
+                byUUID.remove(user.getUUID())
+                byDiscordId.remove(user.discordId)
+                byUsername.remove(user.userName)
+            }
+        }
+
+        @JvmStatic
+        fun byId(id: Int) = byId[id] ?: useDb { findById(id)?.also { cache(it) } }
+
+        @JvmStatic
+        fun get(uuid: UUID) = byUUID[uuid] ?: useDb { find { SteamwarUserTable.uuid eq uuid.toString() }.firstOrNull()?.also { cache(it) } }
+
+        @JvmStatic
+        fun get(discordId: Long) = byDiscordId[discordId] ?: useDb { find { SteamwarUserTable.discordId eq discordId }.firstOrNull()?.also { cache(it) } }
+
+        @JvmStatic
+        fun get(username: String) = byUsername[username] ?: useDb { find { SteamwarUserTable.username eq username }.firstOrNull()?.also { cache(it) } }
+
+        private fun cache(user: SteamwarUser) {
+            byId[user.getId()] = user
+            byUUID[user.getUUID()] = user
+            user.discordId?.let { byDiscordId[it] = user }
+            byUsername[user.userName] = user
+        }
+
+        @JvmStatic
+        fun getOrCreate(uuid: UUID, name: String, newPlayer: Consumer<UUID>): SteamwarUser {
+            val user = get(uuid)
+
+            return if (user != null) {
+                if (user.userName != name) {
+                    useDb {
+                        user.userName = name
+                    }
+                }
+
+                user
+            } else {
+                useDb {
+                    SteamwarUserTable.insert {
+                        it[SteamwarUserTable.uuid] = uuid.toString()
+                        it[username] = name
+                    }
+                }
+
+                newPlayer.accept(uuid)
+                get(uuid) ?: error("User $uuid not found after creation!")
+            }
+        }
+
+        @JvmStatic
+        fun getUsersWithPerm(perm: UserPerm) = useDb {
+            UserPermTable.join(SteamwarUserTable, JoinType.INNER, UserPermTable.user, SteamwarUserTable.id)
+                .select(SteamwarUserTable.fields).where { UserPermTable.perm eq perm }.map { wrapRow(it) }
+        }
+
+        @JvmStatic
+        fun getServerTeam() = useDb { listOf(
+            getUsersWithPerm(UserPerm.PREFIX_ADMIN),
+            getUsersWithPerm(UserPerm.PREFIX_DEVELOPER),
+            getUsersWithPerm(UserPerm.PREFIX_MODERATOR),
+            getUsersWithPerm(UserPerm.PREFIX_SUPPORTER),
+            getUsersWithPerm(UserPerm.PREFIX_BUILDER),
+        ).flatten() }
+
+        @JvmStatic
+        fun getTeam(teamId: Int) = useDb {
+            find { SteamwarUserTable.team eq teamId }.toList()
+        }
+
+        @JvmStatic
+        fun batchCache(ids: MutableSet<Int>) {
+            ids.removeIf(byId::containsKey)
+            if(ids.isEmpty()) return
+
+            useDb {
+                find { SteamwarUserTable.id inList ids }.forEach { cache(it) }
+            }
+        }
+    }
+
+    val uuid: UUID by SteamwarUserTable.uuid.transform({ it.toString() }, { UUID.fromString(it) })
+    var userName by SteamwarUserTable.username
+    private var teamInternal by SteamwarUserTable.team
+    var team: Int
+        get() = teamInternal
+        set(value) = useDb {
+            teamInternal = value
+            leaderInternal = false
+        }
+
+    private var leaderInternal by SteamwarUserTable.leader
+    var leader: Boolean
+        get() = leaderInternal
+        set(value) = useDb {
+            leaderInternal = value
+        }
+    fun isLeader() = leader
+
+    var locale: Locale by SteamwarUserTable.locale
+        .transform({ it.toLanguageTag() }, { it?.let { Locale.forLanguageTag(it) } ?: Locale.getDefault()})
+    var manualLocale by SteamwarUserTable.manualeLocale
+    var bedrock by SteamwarUserTable.bedrock
+    private var passwordInternal by SteamwarUserTable.password
+    var password: String?
+        get() = passwordInternal
+        set(value) {
+            if(value == null) {
+                useDb {
+                    passwordInternal = null
+                }
+                return
+            }
+
+            val salt = ByteArray(16)
+            random.nextBytes(salt)
+            val saltString = Base64.getEncoder().encode(salt)
+
+            val hash = generateHash(value, salt)
+            val hashString = Base64.getEncoder().encode(hash)
+
+            useDb {
+                passwordInternal = "$hashString:$saltString"
+            }
+        }
+
+    var discordId by SteamwarUserTable.discordId
+
+    private val punishments by lazy { Punishment.getPunishmentsOfPlayer(id.value) }
+    private val perms by lazy { UserPerm.getPerms(id.value) }
+    private val prefix by lazy { perms.firstOrNull { UserPerm.prefixes.containsKey(it) }?.let { UserPerm.prefixes[it]} ?: UserPerm.emptyPrefix }
+
+    fun getUUID(): UUID = uuid
+    fun getId() = id.value
+
+    fun getPunishment(punishment: Punishment.PunishmentType) = punishments[punishment]
+    fun isPunished(punishment: Punishment.PunishmentType) = getPunishment(punishment)
+        ?.let {
+            if (!it.isCurrent) {
+                if (punishment == Punishment.PunishmentType.Ban) {
+                    BannedUserIPs.unbanIPs(id.value)
+                }
+                punishments.remove(punishment)
+                return@let false
+            }
+
+            return@let true
+        } ?: false
+
+    fun hasPerm(perm: UserPerm) = perms.contains(perm)
+    fun perms() = perms
+    fun prefix() = prefix
+
+    fun getOnlinetime() = useDb {
+        exec("SELECT SUM(UNIX_TIMESTAMP(EndTime) - UNIX_TIMESTAMP(StartTime)) as Playtime FROM Session WHERE UserID = ${this@SteamwarUser.id.value}") { rs ->
+            return@exec if (rs.next()) {
+                rs.getBigDecimal("Playtime").toDouble()
+            } else {
+                0.0
+            }
+        } ?: 0.0
+    }
+
+    fun getFirstjoin() = useDb {
+        exec("SELECT MIN(StartTime) AS FirstJoin FROM Session WHERE UserID = ${this@SteamwarUser.id.value}") { rs ->
+            return@exec if (rs.next()) {
+                rs.getTimestamp("FirstJoin")
+            } else { null }
+        }
+    }
+
+    fun getLastOnline() = useDb {
+        exec("SELECT MAX(EndTime) AS LastOnline FROM Session WHERE UserID = ${this@SteamwarUser.id.value}") { rs ->
+            return@exec if (rs.next()) {
+                rs.getTimestamp("LastOnline")
+            } else { null }
+        }
+    }
+
+    fun punish(punishment: Punishment.PunishmentType, time: Timestamp, reason: String, from: Int, perma: Boolean) = useDb {
+        punishments.remove(punishment)
+        punishments[punishment] = Punishment.createPunishment(this@SteamwarUser.id.value, from, punishment, reason, time, perma)
+    }
+
+    fun setLocale(locale: Locale?, manualeLocale: Boolean) {
+        if (locale == null || (this.manualLocale && !manualLocale)) return
+
+        useDb {
+            this@SteamwarUser.locale = locale
+            this@SteamwarUser.manualLocale = manualeLocale
+        }
+    }
+
+    fun setDiscordId(discordId: Long) {
+        byDiscordId.remove(this.discordId)
+        useDb {
+            this@SteamwarUser.discordId = discordId
+        }
+        byDiscordId[discordId] = this
+    }
+
+    fun verifyPassword(password: String): Boolean {
+        if (!hasPassword()) return false
+
+        val (hashString, saltString) = this.password!!.split(':')
+
+        val hash = Base64.getDecoder().decode(hashString)
+        val salt = Base64.getDecoder().decode(saltString)
+
+        return hash.contentEquals(generateHash(password, salt))
+    }
+
+    fun hasPassword() = password != null
+
+    fun generateHash(password: String, salt: ByteArray): ByteArray =
+        PBEKeySpec(password.toCharArray(), salt, 65536, 128).let { factory.generateSecret(it).encoded }
+}

CommonCore/SQL/src/de/steamwar/sql/Token.java

@@ -105,6 +105,6 @@ public class Token {
     }
 
     public SteamwarUser getOwner() {
-        return SteamwarUser.get(owner);
+        return SteamwarUser.byId(owner);
     }
 }

CommonCore/SQL/src/de/steamwar/sql/UserPerm.kt

@@ -17,16 +17,24 @@
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package de.steamwar.sql;
+package de.steamwar.sql
 
-import de.steamwar.sql.internal.*;
+import de.steamwar.sql.internal.useDb
-import lombok.AllArgsConstructor;
+import org.jetbrains.exposed.v1.core.Table
-import lombok.Getter;
+import org.jetbrains.exposed.v1.core.and
+import org.jetbrains.exposed.v1.core.eq
+import org.jetbrains.exposed.v1.jdbc.deleteWhere
+import org.jetbrains.exposed.v1.jdbc.insert
+import org.jetbrains.exposed.v1.jdbc.selectAll
 
-import java.util.*;
+object UserPermTable: Table("UserPerm") {
-import java.util.stream.Collectors;
+    val user = reference("User", SteamwarUserTable.id)
+    val perm = enumerationByName("Perm", 32, UserPerm::class)
 
-public enum UserPerm {
+    override val primaryKey = PrimaryKey(user, perm)
+}
+
+enum class UserPerm {
     PREFIX_NONE, // special value, not stored in database
     PREFIX_YOUTUBER,
     PREFIX_GUIDE,
@@ -45,54 +53,41 @@ public enum UserPerm {
     MODERATION,
     ADMINISTRATION;
 
-    public static final Map<UserPerm, Prefix> prefixes;
+    companion object {
-    public static final Prefix emptyPrefix;
+        @JvmField
-    static {
+        val emptyPrefix = Prefix("§7", "")
-        // https://www.digminecraft.com/lists/color_list_pc.php
+        @JvmField
-        SqlTypeMapper.nameEnumMapper(UserPerm.class);
+        val prefixes = mapOf(
-        Map<UserPerm, Prefix> p = new EnumMap<>(UserPerm.class);
+            PREFIX_NONE to emptyPrefix,
-        emptyPrefix = new Prefix("§7", "");
+            PREFIX_YOUTUBER to Prefix("§7", "YT"),
-        p.put(PREFIX_NONE, emptyPrefix);
+            PREFIX_GUIDE to Prefix("§x§e§7§6§2§e§d", "Guide"), // E762ED
-        p.put(PREFIX_YOUTUBER, new Prefix("§7", "YT"));
+            PREFIX_SUPPORTER to Prefix("§x§6§0§9§5§F§B", "Sup"), // 6095FB
-        p.put(PREFIX_GUIDE, new Prefix("§x§e§7§6§2§e§d", "Guide")); // E762ED
+            PREFIX_MODERATOR to Prefix("§x§F§F§A§2§5§C", "Mod"), // FFA25C
+            PREFIX_BUILDER to Prefix("§x§6§0§F§F§6§A", "Arch"), // 60FF6A
+            PREFIX_DEVELOPER to Prefix("§x§0§B§B§C§B§3", "Dev"), // 0BBCB3
+            PREFIX_ADMIN to Prefix("§x§F§F§2§B§2§4", "Admin"), // FF2B24
+        )
 
-        p.put(PREFIX_SUPPORTER, new Prefix("§x§6§0§9§5§F§B", "Sup")); // 6095FB
+        @JvmStatic
-        p.put(PREFIX_MODERATOR, new Prefix("§x§F§F§A§2§5§C", "Mod")); // FFA25C
+        fun getPerms(id: Int) = useDb {
-        p.put(PREFIX_BUILDER, new Prefix("§x§6§0§F§F§6§A", "Arch")); // 60FF6A
+            UserPermTable.selectAll().where { UserPermTable.user eq id }.map { it[UserPermTable.perm] }.toSet()
-        p.put(PREFIX_DEVELOPER, new Prefix("§x§0§B§B§C§B§3", "Dev")); // 0BBCB3
+        }
-        p.put(PREFIX_ADMIN, new Prefix("§x§F§F§2§B§2§4", "Admin")); // FF2B24
+
-        prefixes = Collections.unmodifiableMap(p);
+        @JvmStatic
+        fun addPerm(user: SteamwarUser, perm: UserPerm) = useDb {
+            UserPermTable.insert {
+                it[UserPermTable.user] = user.getId()
+                it[UserPermTable.perm] = perm
+            }
+        }
+
+        @JvmStatic
+        fun removePerm(user: SteamwarUser, perm: UserPerm) = useDb {
+            UserPermTable.deleteWhere {
+                (UserPermTable.user eq user.getId()) and (UserPermTable.perm eq perm)
+            }
+        }
     }
 
-    private static final Table<UserPermTable> table = new Table<>(UserPermTable.class, "UserPerm");
+    data class Prefix(val colorCode: String, val chatPrefix: String)
-    private static final SelectStatement<UserPermTable> getPerms = table.selectFields("user");
+}
-    private static final Statement addPerm = table.insertAll();
-    private static final Statement removePerm = table.delete(Table.PRIMARY);
-
-    public static Set<UserPerm> getPerms(int user) {
-        return getPerms.listSelect(user).stream().map(up -> up.perm).collect(Collectors.toSet());
-    }
-
-    public static void addPerm(SteamwarUser user, UserPerm perm) {
-        addPerm.update(user, perm);
-    }
-
-    public static void removePerm(SteamwarUser user, UserPerm perm) {
-        removePerm.update(user, perm);
-    }
-
-    @Getter
-    @AllArgsConstructor
-    public static class Prefix {
-        private final String colorCode;
-        private final String chatPrefix;
-    }
-
-    @AllArgsConstructor
-    public static class UserPermTable {
-        @Field(keys = {Table.PRIMARY})
-        private final int user;
-        @Field(keys = {Table.PRIMARY})
-        private final UserPerm perm;
-    }
-}

CommonCore/SQL/src/de/steamwar/sql/internal/KotlinDatabase.kt

@@ -0,0 +1,58 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.sql.internal
+
+import org.jetbrains.exposed.v1.jdbc.Database
+import org.jetbrains.exposed.v1.jdbc.JdbcTransaction
+import org.jetbrains.exposed.v1.jdbc.transactions.TransactionManager
+import org.jetbrains.exposed.v1.jdbc.transactions.transaction
+import java.io.File
+import java.util.Properties
+
+object KotlinDatabase {
+    lateinit var db: Database
+
+    fun ensureConnected() {
+        if(KotlinDatabase::db.isInitialized) return
+
+        val file = File(System.getProperty("user.home"), "mysql.properties")
+
+        val properties = Properties()
+        properties.load(file.inputStream())
+
+        val host = properties.getProperty("host")
+        val port = properties.getProperty("port")
+        val database = properties.getProperty("database")
+        val username = properties.getProperty("user")
+        val password = properties.getProperty("password")
+
+        db = Database.connect(
+            "jdbc:mysql://$host:$port/$database",
+            driver = "com.mysql.cj.jdbc.Driver",
+            user = username,
+            password = password
+        )
+    }
+}
+
+fun <T: Any?> useDb(statement: JdbcTransaction.() -> T): T {
+    KotlinDatabase.ensureConnected()
+    return TransactionManager.currentOrNull()?.statement() ?: transaction(KotlinDatabase.db, statement)
+}

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/commands/InfoCommand.java

@@ -58,7 +58,7 @@ public class InfoCommand implements CommandExecutor {
 
             if(team.getSchematic() != 0) {
                 SchematicNode schematic = SchematicNode.getSchematicNode(team.getSchematic());
-                FightSystem.getMessage().send("INFO_SCHEMATIC", player, team.getColoredName(), schematic.getName(), SteamwarUser.get(schematic.getOwner()).getUserName(), schematic.getRank());
+                FightSystem.getMessage().send("INFO_SCHEMATIC", player, team.getColoredName(), schematic.getName(), SteamwarUser.byId(schematic.getOwner()).getUserName(), schematic.getRank());
             }
         }
         return false;

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/FightPlayer.java

@@ -94,7 +94,7 @@ public class FightPlayer {
     }
 
     public SteamwarUser getUser() {
-        return SteamwarUser.get(id);
+        return SteamwarUser.byId(id);
     }
 
     public void ifAI(Consumer<AI> function) {

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/record/PacketProcessor.java

@@ -243,7 +243,7 @@ public class PacketProcessor implements Listener {
         int userId = source.readInt();
 
         execSync(() -> {
-            SteamwarUser user = SteamwarUser.get(userId);
+            SteamwarUser user = SteamwarUser.byId(userId);
             addREntity(entityId, new RPlayer(entityServer, user.getUUID(), user.getUserName(), Config.SpecSpawn));
             team.addEntry(user.getUserName());
 

LegacyBauSystem/src/de/steamwar/bausystem/BauSystem.java

@@ -116,7 +116,7 @@ public class BauSystem extends JavaPlugin implements Listener {
     }
 
     public static UUID getOwner() {
-        return SteamwarUser.get(getOwnerID()).getUUID();
+        return SteamwarUser.byId(getOwnerID()).getUUID();
     }
 
     public static int getOwnerID() {

LegacyBauSystem/src/de/steamwar/bausystem/Mapper.java

@@ -78,10 +78,10 @@ public class Mapper {
     private static TypeMapper<BauweltMember> bauweltMemberTypeMapper() {
         return SWCommandUtils.createMapper(s -> BauweltMember.getMembers(BauSystem.getOwnerID())
                                                              .stream()
-                                                             .filter(m -> SteamwarUser.get(m.getMemberID()).getUserName().equals(s)).findFirst().orElse(null),
+                                                             .filter(m -> SteamwarUser.byId(m.getMemberID()).getUserName().equals(s)).findFirst().orElse(null),
                                            s -> BauweltMember.getMembers(BauSystem.getOwnerID())
                                                              .stream()
-                                                             .map(m -> SteamwarUser.get(m.getMemberID()).getUserName())
+                                                             .map(m -> SteamwarUser.byId(m.getMemberID()).getUserName())
                                                              .collect(Collectors.toList()));
     }
 }

LegacyBauSystem/src/de/steamwar/bausystem/commands/CommandInfo.java

@@ -49,7 +49,7 @@ public class CommandInfo extends SWCommand {
     }
 
     public static void sendBauInfo(Player p) {
-        p.sendMessage(BauSystem.PREFIX + "Besitzer: §e" + SteamwarUser.get(BauSystem.getOwnerID()).getUserName());
+        p.sendMessage(BauSystem.PREFIX + "Besitzer: §e" + SteamwarUser.byId(BauSystem.getOwnerID()).getUserName());
         Region region = Region.getRegion(p.getLocation());
         p.sendMessage(BauSystem.PREFIX + "§eTNT§8: " + region.getTntMode().getName() + " §eFire§8: " + (region.isFire() ? "§aAUS" : "§cAN") + " §eFreeze§8: " + (region.isFreeze() ? "§aAN" : "§cAUS"));
         if (region.hasProtection()) {
@@ -60,7 +60,7 @@ public class CommandInfo extends SWCommand {
         StringBuilder membermessage = new StringBuilder().append(BauSystem.PREFIX).append("Mitglieder: ");
 
         for (BauweltMember member : members) {
-            membermessage.append("§e").append(SteamwarUser.get(member.getMemberID()).getUserName()).append("§8[");
+            membermessage.append("§e").append(SteamwarUser.byId(member.getMemberID()).getUserName()).append("§8[");
             membermessage.append(member.isWorldEdit() ? "§a" : "§c").append("WE").append("§8,");
             membermessage.append(member.isWorld() ? "§a" : "§c").append("W").append("§8]").append(" ");
         }

LegacyBauSystem/src/de/steamwar/bausystem/commands/CommandLockschem.java

@@ -56,7 +56,7 @@ public class CommandLockschem extends SWCommand {
             return;
         }
         p.sendMessage(BauSystem.PREFIX + "Schematic " + node .getName() + " von " +
-                SteamwarUser.get(node.getOwner()).getUserName() + " von " + node.getSchemtype().toString() +
+                SteamwarUser.byId(node.getOwner()).getUserName() + " von " + node.getSchemtype().toString() +
                 " auf NORMAL zurückgesetzt!");
         node.setSchemtype(SchematicType.Normal);
     }

LobbySystem/src/de/steamwar/lobby/LobbyPacketHandler.java

@@ -41,7 +41,7 @@ public class LobbyPacketHandler extends PacketHandler {
 
     @Handler
     public void serverStarting(StartingServerPacket packet) {
-        Player player = Objects.requireNonNull(Bukkit.getPlayer(SteamwarUser.get(packet.getUser()).getUUID()));
+        Player player = Objects.requireNonNull(Bukkit.getPlayer(SteamwarUser.byId(packet.getUser()).getUUID()));
         player.teleport(LobbySystem.config().getWaitingHallSpawn(), PlayerTeleportEvent.TeleportCause.PLUGIN);
         if (JumpAndRun.isPlayerInJumpAndRun(player)) {
             JumpAndRun.reset(player);

LobbySystem/src/de/steamwar/lobby/particle/ParticleRequirement.java

@@ -185,7 +185,7 @@ public interface ParticleRequirement {
     }
 
     static ParticleRequirement specificPlayer(int userId) {
-        String userName = SteamwarUser.get(userId).getUserName();
+        String userName = SteamwarUser.byId(userId).getUserName();
         return new ParticleRequirement() {
             @Override
             public String getRequirementName(Player player) {
@@ -200,7 +200,7 @@ public interface ParticleRequirement {
     }
 
     static ParticleRequirement easterEventSpecificPlayer(int userId) {
-        String userName = SteamwarUser.get(userId).getUserName();
+        String userName = SteamwarUser.byId(userId).getUserName();
         return new ParticleRequirement() {
             @Override
             public String getRequirementName(Player player) {

LobbySystem/src/de/steamwar/lobby/portal/FightserverPortal.java

@@ -122,7 +122,7 @@ public class FightserverPortal implements PortalHandler, Comparable<FightserverP
     }
 
     private void updateNPCs(List<Location> locations, List<NPC> npcs, List<Integer> players) {
-        List<SteamwarUser> remainingPlayers = players.stream().map(SteamwarUser::get).collect(Collectors.toList());
+        List<SteamwarUser> remainingPlayers = players.stream().map(SteamwarUser::byId).collect(Collectors.toList());
         List<Location> remainingLocations = new ArrayList<>(locations);
         npcs.removeIf(npc -> {
             SteamwarUser user = SteamwarUser.get(npc.getUuid());

LobbySystem/src/de/steamwar/lobby/util/Leaderboard.java

@@ -71,7 +71,7 @@ public class Leaderboard implements Listener {
         for (int i = 0; i < leaderboard.size(); i++) {
             LeaderboardEntry entry = leaderboard.get(i);
             RArmorStand entity = new RArmorStand(server, location.clone().add(0, (leaderboard.size() - i - 1) * 0.32, 0), RArmorStand.Size.MARKER);
-            SteamwarUser user = SteamwarUser.get(entry.user);
+            SteamwarUser user = SteamwarUser.byId(entry.user);
             String color = "§7";
             if (i == 0) {
                 color = "§6§l";

SchematicSystem/SchematicSystem_Core/src/de/steamwar/schematicsystem/commands/schematiccommand/GUI.java

@@ -197,7 +197,7 @@ public class GUI {
                 inv.setItem(4, SWItem.getMaterial("CAULDRON_ITEM"), SchematicSystem.MESSAGE.parse("GUI_INFO_TYPE", player, node.getSchemtype().name()), Collections.emptyList(), node.getSchemtype().fightType(), click -> {});
             }
 
-            SteamwarUser owneruser = SteamwarUser.get(node.getOwner());
+            SteamwarUser owneruser = SteamwarUser.byId(node.getOwner());
             SWItem skull = SWItem.getPlayerSkull(owneruser.getUserName());
             skull.setName(SchematicSystem.MESSAGE.parse("GUI_INFO_MEMBER_FROM", player, owneruser.getUserName()));
             inv.setItem(8, skull.getItemStack(), clickType -> {});
@@ -316,7 +316,7 @@ public class GUI {
     static void delmembers(Player p, SchematicNode schem){
         List<SWListInv.SWListEntry<NodeMember>> members = new LinkedList<>();
         for(NodeMember member : schem.getMembers()){
-            SteamwarUser user = SteamwarUser.get(member.getMember());
+            SteamwarUser user = SteamwarUser.byId(member.getMember());
             members.add(new SWListInv.SWListEntry<>(SWItem.getPlayerSkull(user.getUserName()), member));
         }
 

SchematicSystem/SchematicSystem_Core/src/de/steamwar/schematicsystem/commands/schematiccommand/SchematicCommandUtils.java

@@ -141,7 +141,7 @@ public class SchematicCommandUtils {
             }
 
             if (node.getOwner() != user.getId()) {
-                nodeString.append(" ").append(SchematicSystem.MESSAGE.parse("UTIL_LIST_FROM", player, SteamwarUser.get(node.getOwner()).getUserName()));
+                nodeString.append(" ").append(SchematicSystem.MESSAGE.parse("UTIL_LIST_FROM", player, SteamwarUser.byId(node.getOwner()).getUserName()));
             }
             TextComponent schematics = new TextComponent(nodeString.toString());
 
@@ -213,7 +213,7 @@ public class SchematicCommandUtils {
         } else {
             SchematicSystem.MESSAGE.sendPrefixless("UTIL_INFO_NAME", player, node.getName());
         }
-        SchematicSystem.MESSAGE.sendPrefixless("UTIL_INFO_OWNER", player, node.getOwner() == user.getId() ? user.getUserName() : SteamwarUser.get(node.getOwner()).getUserName());
+        SchematicSystem.MESSAGE.sendPrefixless("UTIL_INFO_OWNER", player, node.getOwner() == user.getId() ? user.getUserName() : SteamwarUser.byId(node.getOwner()).getUserName());
         if(node.getOwner() == user.getId()) {
             player.spigot().sendMessage(
                     new ComponentBuilder(SchematicSystem.MESSAGE.parseToComponent("UTIL_INFO_PARENT", false, player, node.getParent() == null ? "/" : node.getParentNode().generateBreadcrumbs()))
@@ -261,7 +261,7 @@ public class SchematicCommandUtils {
         if(node.getOwner() == user.getId()) {
             ComponentBuilder memberBuilder = new ComponentBuilder(SchematicSystem.MESSAGE.parse("UTIL_INFO_MEMBER_STRING", player) + " ").color(ChatColor.GRAY);
             NodeMember.getNodeMembers(node.getId()).forEach(nodeMember -> {
-                SteamwarUser member = SteamwarUser.get(nodeMember.getMember());
+                SteamwarUser member = SteamwarUser.byId(nodeMember.getMember());
                 memberBuilder.append(member.getUserName())
                         .color(ChatColor.YELLOW)
                         .event(new ClickEvent(ClickEvent.Action.SUGGEST_COMMAND, "/schem delmember " + node.generateBreadcrumbs() + " " + member.getUserName()))
@@ -275,7 +275,7 @@ public class SchematicCommandUtils {
             player.spigot().sendMessage(memberBuilder.create());
         } else {
             List<String> schematicMembers = new ArrayList<>();
-            NodeMember.getNodeMembers(node.getId()).forEach(nodeMember -> schematicMembers.add(SteamwarUser.get(nodeMember.getMember()).getUserName()));
+            NodeMember.getNodeMembers(node.getId()).forEach(nodeMember -> schematicMembers.add(SteamwarUser.byId(nodeMember.getMember()).getUserName()));
             if(!schematicMembers.isEmpty()) {
                 SchematicSystem.MESSAGE.sendPrefixless("UTIL_INFO_MEMBER", player, schematicMembers.stream().reduce((s, s2) -> s + ", " + s2).orElse(""));
             }
@@ -343,7 +343,7 @@ public class SchematicCommandUtils {
 
     public static SteamwarUser getUser(Player player) {
         if (PUBLIC_TOGGLED.contains(player)) {
-            return SteamwarUser.get(0);
+            return SteamwarUser.byId(0);
         } else {
             return SteamwarUser.get(player.getUniqueId());
         }
@@ -368,7 +368,7 @@ public class SchematicCommandUtils {
         if(BauServerInfo.isBauServer() && BauServerInfo.getOwnerId() != user.getId() &&
                 (Punishment.isPunished(user, Punishment.PunishmentType.NoSchemSharing, punishment ->
                         SchematicSystem.MESSAGE.send("UTIL_LOAD_NOT_HERE", player)) ||
-                Punishment.isPunished(SteamwarUser.get(BauServerInfo.getOwnerId()), Punishment.PunishmentType.NoSchemReceiving, punishment ->
+                Punishment.isPunished(SteamwarUser.byId(BauServerInfo.getOwnerId()), Punishment.PunishmentType.NoSchemReceiving, punishment ->
                         SchematicSystem.MESSAGE.send("UTIL_LOAD_NOT_HERE_ALL", player)))) {
             return;
         }

SchematicSystem/SchematicSystem_Core/src/de/steamwar/schematicsystem/commands/schematiccommand/SchematicMapper.java

@@ -46,12 +46,12 @@ public class SchematicMapper {
         return new TypeMapper<SchematicNode>() {
             @Override
             public List<String> tabCompletes(CommandSender commandSender, String[] strings, String s) {
-                return SchematicNode.getNodeTabcomplete(SteamwarUser.get(0), s);
+                return SchematicNode.getNodeTabcomplete(SteamwarUser.byId(0), s);
             }
 
             @Override
             public SchematicNode map(CommandSender commandSender, String[] previousArguments, String s) {
-                return SchematicNode.getNodeFromPath(SteamwarUser.get(0), s);
+                return SchematicNode.getNodeFromPath(SteamwarUser.byId(0), s);
             }
         };
     }
@@ -69,7 +69,7 @@ public class SchematicMapper {
             public List<String> tabCompletes(CommandSender commandSender, String[] strings, String s) {
                 return Optional.ofNullable(SchematicNode.getNodeFromPath(getUser((Player) commandSender), strings[strings.length - 1]))
                         .map(SchematicNode::getMembers)
-                        .map(nodeMembers -> nodeMembers.stream().map(NodeMember::getMember).map(SteamwarUser::get).map(SteamwarUser::getUserName).collect(Collectors.toList()))
+                        .map(nodeMembers -> nodeMembers.stream().map(NodeMember::getMember).map(SteamwarUser::byId).map(SteamwarUser::getUserName).collect(Collectors.toList()))
                         .orElse(Collections.emptyList());
             }
         };

SchematicSystem/SchematicSystem_Core/src/de/steamwar/schematicsystem/commands/schematiccommand/parts/MemberPart.java

@@ -92,7 +92,7 @@ public class MemberPart extends SWCommand {
     @Register("delmember")
     public void delMember(Player player, @Validator("isOwnerValidator") SchematicNode node, @Mapper("memberMapper") NodeMember member) {
         SteamwarUser user = getUser(player);
-        SteamwarUser target = SteamwarUser.get(member.getMember());
+        SteamwarUser target = SteamwarUser.byId(member.getMember());
 
         List<SchematicNode> nodes = SchematicNode.deepGet(node.getId(), node1 -> node1.getOwner() != user.getId());
         if (!nodes.isEmpty()) {
@@ -123,7 +123,7 @@ public class MemberPart extends SWCommand {
             return;
         }
 
-        addMember(player, node, team.getMembers().stream().map(SteamwarUser::get).filter(steamwarUser -> steamwarUser.getId() != user.getId()).toArray(SteamwarUser[]::new));
+        addMember(player, node, team.getMembers().stream().map(SteamwarUser::byId).filter(steamwarUser -> steamwarUser.getId() != user.getId()).toArray(SteamwarUser[]::new));
     }
 
     @Register("delteam")
@@ -141,7 +141,7 @@ public class MemberPart extends SWCommand {
             NodeMember nodeMember = NodeMember.getNodeMember(node.getId(), member);
             if (nodeMember != null) {
                 nodeMember.delete();
-                removed.add(SteamwarUser.get(member).getUserName());
+                removed.add(SteamwarUser.byId(member).getUserName());
             }
         }
 

SchematicSystem/SchematicSystem_Core/src/de/steamwar/schematicsystem/commands/schematiccommand/parts/SavePart.java

@@ -66,7 +66,7 @@ public class SavePart extends SWCommand {
         if(BauServerInfo.isBauServer() && BauServerInfo.getOwnerId() != user.getId() &&
                 (Punishment.isPunished(user, Punishment.PunishmentType.NoSchemReceiving, punishment ->
                         SchematicSystem.MESSAGE.send("COMMAND_PUNISHMENT_NO_SAVE_EXTERNAL", player)) ||
-                        Punishment.isPunished(SteamwarUser.get(BauServerInfo.getOwnerId()), Punishment.PunishmentType.NoSchemSharing, punishment ->
+                        Punishment.isPunished(SteamwarUser.byId(BauServerInfo.getOwnerId()), Punishment.PunishmentType.NoSchemSharing, punishment ->
                                 SchematicSystem.MESSAGE.send("COMMAND_PUNISHMENT_NO_SAVE", player)))) {
             return;
         }

SchematicSystem/SchematicSystem_Core/src/de/steamwar/schematicsystem/commands/schematiccommand/parts/SearchPart.java

@@ -135,7 +135,7 @@ public class SearchPart extends SWCommand {
             i++;
         }
 
-        List<SchematicNode> nodes = SchematicNode.getAll(SteamwarUser.get(userId)).stream().filter(node -> {
+        List<SchematicNode> nodes = SchematicNode.getAll(SteamwarUser.byId(userId)).stream().filter(node -> {
             for (Predicate<SchematicNode> predicate : predicates) {
                 if (!predicate.test(node)) {
                     return false;

SchematicSystem/SchematicSystem_Core/src/de/steamwar/schematicsystem/commands/schematiccommand/parts/ViewPart.java

@@ -60,7 +60,7 @@ public class ViewPart extends SWCommand {
     @Register({"list", "public"})
     @Register({"list", "public", "/"})
     public void schemListPublic(Player player, @OptionalValue(value = "1", onlyUINIG = true) int page) {
-        createCachedSchemList(player, SchematicNode.list(SteamwarUser.get(0), null), Math.max(page - 1, 0), null, SchematicCommandUtils.SchematicListBehavior.builder().setPublics(true).setPageCommandGen(integer -> "/schem list public " + integer).build());
+        createCachedSchemList(player, SchematicNode.list(SteamwarUser.byId(0), null), Math.max(page - 1, 0), null, SchematicCommandUtils.SchematicListBehavior.builder().setPublics(true).setPageCommandGen(integer -> "/schem list public " + integer).build());
     }
 
     @Register("list")

SpigotCore/SpigotCore_Main/src/de/steamwar/command/TypeUtils.java

@@ -67,7 +67,7 @@ public class TypeUtils {
                 Player player = (Player) commandSender;
                 return BauweltMember.getMembers(player.getUniqueId())
                         .stream()
-                        .filter(member -> SteamwarUser.get(member.getMemberID()).getUserName().equalsIgnoreCase(s))
+                        .filter(member -> SteamwarUser.byId(member.getMemberID()).getUserName().equalsIgnoreCase(s))
                         .findAny()
                         .orElse(null);
             }
@@ -80,7 +80,7 @@ public class TypeUtils {
                 Player player = (Player) sender;
                 return BauweltMember.getMembers(player.getUniqueId())
                         .stream()
-                        .map(m -> SteamwarUser.get(m.getMemberID()).getUserName())
+                        .map(m -> SteamwarUser.byId(m.getMemberID()).getUserName())
                         .collect(Collectors.toList());
             }
         });

SpigotCore/SpigotCore_Main/src/de/steamwar/inventory/SchematicSelector.java

@@ -84,7 +84,7 @@ public class SchematicSelector {
     public void open() {
         injectable.onSelectorCreate(this);
         if(publicMode == PublicMode.PUBLIC_ONLY) {
-            this.user = SteamwarUser.get(0);
+            this.user = SteamwarUser.byId(0);
         }
         openList(null);
         injectable.onSelectorOpen(this, SchematicSelectorInjectable.OpenFrom.FRESH);
@@ -131,7 +131,7 @@ public class SchematicSelector {
                 }).setCustomModelData(CMDs.Schematic.OWN_SCHEMS));
             } else {
                 inv.setItem(48, new SWItem(Material.GLASS, Core.MESSAGE.parse("SCHEM_SELECTOR_PUB", player), clickType -> {
-                    this.user = SteamwarUser.get(0);
+                    this.user = SteamwarUser.byId(0);
                     openList(null);
                 }).setCustomModelData(CMDs.Schematic.PUBLIC_SCHEMS));
             }
@@ -326,7 +326,7 @@ public class SchematicSelector {
         if(filter.getOwner() == null) {
             inv.setItem(1, SWItem.getMaterial("SKULL_ITEM"), (byte) 3, Core.MESSAGE.parse("SCHEM_SELECTOR_FILTER_OWNER", player), ownerCallback);
         } else {
-            SteamwarUser tUser = SteamwarUser.get(filter.getOwner());
+            SteamwarUser tUser = SteamwarUser.byId(filter.getOwner());
             SWItem item = SWItem.getPlayerSkull(tUser.getUserName());
             item.setName(Core.MESSAGE.parse("SCHEM_SELECTOR_FILTER_OWNER", player));
             item.setEnchanted(true);
@@ -485,7 +485,7 @@ public class SchematicSelector {
     }
 
     private static Optional<SchematicNode> getParent(SchematicNode node) {
-        return node.getOptionalParent().map(integer -> SchematicNode.byIdAndUser(SteamwarUser.get(node.getEffectiveOwner()), integer));
+        return node.getOptionalParent().map(integer -> SchematicNode.byIdAndUser(SteamwarUser.byId(node.getEffectiveOwner()), integer));
     }
 
     public static SelectorTarget selectSchematic() {
@@ -585,7 +585,7 @@ public class SchematicSelector {
                 lore.add(Core.MESSAGE.parse("SCHEM_SELECTOR_FILTER_NAME_SEARCH", player, name));
             }
             if(owner != null) {
-                lore.add(Core.MESSAGE.parse("SCHEM_SELECTOR_FILTER_OWNER_SEARCH", player, SteamwarUser.get(owner).getUserName()));
+                lore.add(Core.MESSAGE.parse("SCHEM_SELECTOR_FILTER_OWNER_SEARCH", player, SteamwarUser.byId(owner).getUserName()));
             }
             if(type != null) {
                 lore.add(Core.MESSAGE.parse("SCHEM_SELECTOR_FILTER_TYPE_SEARCH", player, type.name()));
@@ -606,7 +606,7 @@ public class SchematicSelector {
             if (name != null) {
                 return new SWItem(Material.NAME_TAG, itemName, lore, false, click -> {});
             } else if (owner != null) {
-                SWItem playerSkull = SWItem.getPlayerSkull(SteamwarUser.get(owner).getUserName());
+                SWItem playerSkull = SWItem.getPlayerSkull(SteamwarUser.byId(owner).getUserName());
                 playerSkull.setName(itemName);
                 playerSkull.setLore(lore);
                 return playerSkull;

SpigotCore/SpigotCore_Main/src/de/steamwar/network/CoreNetworkHandler.java

@@ -48,7 +48,7 @@ public class CoreNetworkHandler extends PacketHandler {
 
     @Handler
     public void handleCloseInventoryPacket(CloseInventoryPacket packet) {
-        Player player = Bukkit.getPlayer(SteamwarUser.get(packet.getPlayerId()).getUUID());
+        Player player = Bukkit.getPlayer(SteamwarUser.byId(packet.getPlayerId()).getUUID());
         if (player != null) {
             player.closeInventory();
         }
@@ -66,7 +66,7 @@ public class CoreNetworkHandler extends PacketHandler {
 
     @Handler
     public void handlePingPacket(PingPacket packet) {
-        UUID uuid = SteamwarUser.get(packet.getId()).getUUID();
+        UUID uuid = SteamwarUser.byId(packet.getId()).getUUID();
         if(Bukkit.getPlayer(uuid) != null) {
             Player player = Bukkit.getPlayer(uuid);
             BountifulWrapper.impl.playPling(player);

SpigotCore/SpigotCore_Main/src/de/steamwar/network/handlers/InventoryHandler.java

@@ -24,7 +24,6 @@ import de.steamwar.inventory.SWAnvilInv;
 import de.steamwar.inventory.SWInventory;
 import de.steamwar.inventory.SWItem;
 import de.steamwar.network.NetworkSender;
-import de.steamwar.network.packets.NetworkPacket;
 import de.steamwar.network.packets.PacketHandler;
 import de.steamwar.network.packets.client.AnvilAnswerPacket;
 import de.steamwar.network.packets.client.InventoryCallbackPacket;
@@ -42,7 +41,7 @@ public class InventoryHandler extends PacketHandler {
 
     @Handler
     public static void handleInventoryPacket(InventoryPacket packet) {
-        Player player = Bukkit.getPlayer(SteamwarUser.get(packet.getPlayer()).getUUID());
+        Player player = Bukkit.getPlayer(SteamwarUser.byId(packet.getPlayer()).getUUID());
         Map<Integer, SWItem> items = new HashMap<>();
         packet.getItems().forEach((i, item) -> {
             @SuppressWarnings("deprecation") SWItem it = SWItem.getItemFromJson(new JsonParser().parse(item).getAsJsonObject());
@@ -60,7 +59,7 @@ public class InventoryHandler extends PacketHandler {
 
     @Handler
     public static void handleAnvilInventoryPacket(AnvilInventoryPacket packet) {
-        Player player = Bukkit.getPlayer(SteamwarUser.get(packet.getPlayerId()).getUUID());
+        Player player = Bukkit.getPlayer(SteamwarUser.byId(packet.getPlayerId()).getUUID());
 
         SWAnvilInv inv = new SWAnvilInv(player, packet.getTitle(), packet.getDefaultText());
         if (packet.getMaterial() != null && !packet.getMaterial().isEmpty()) {

SpigotCore/SpigotCore_Main/src/de/steamwar/providers/BauServerInfo.java

@@ -41,6 +41,6 @@ public class BauServerInfo {
 
     public static SteamwarUser getOwnerUser() {
         if (bauOwner == null) return null;
-        return SteamwarUser.get(bauOwner);
+        return SteamwarUser.byId(bauOwner);
     }
 }

TNTLeague/src/de/steamwar/tntleague/game/TNTLeagueGame.kt

@@ -166,7 +166,7 @@ object TNTLeagueGame {
         else if (redTeam.leader == null && TNTLeagueConfig.config.redLeader == null || player.uniqueId == TNTLeagueConfig.config.redLeader) redTeam
         else null
 
-    private fun getEventFreeTeam(player: Player) = SteamwarUser.get(player.uniqueId).let { user ->
+    private fun getEventFreeTeam(player: Player) = SteamwarUser.get(player.uniqueId)!!.let { user ->
         if (user.team == TNTLeagueConfig.config.eventTeamBlue.teamId && blueTeam.members.size < TNTLeagueConfig.config.event.maximumTeamMembers) blueTeam
         else if (user.team == TNTLeagueConfig.config.eventTeamRed.teamId && redTeam.members.size < TNTLeagueConfig.config.event.maximumTeamMembers) redTeam
         else null
@@ -259,13 +259,13 @@ object TNTLeagueGame {
             redTeam.name.message.colorByTeam(redTeam),
             state.lobbyName,
             TNTLeagueConfig.config.gameTime - gameTimeRemaining,
-            blueTeam.leader?.let { SteamwarUser.get(it.uniqueId).id } ?: 0,
+            blueTeam.leader?.let { SteamwarUser.get(it.uniqueId)!!.getId() } ?: 0,
-            redTeam.leader?.let { SteamwarUser.get(it.uniqueId).id } ?: 0,
+            redTeam.leader?.let { SteamwarUser.get(it.uniqueId)!!.getId() } ?: 0,
             0,
             0,
-            blueTeam.members.map { SteamwarUser.get(it.uniqueId).id },
+            blueTeam.members.map { SteamwarUser.get(it.uniqueId)!!.getId() },
-            redTeam.members.map { SteamwarUser.get(it.uniqueId).id },
+            redTeam.members.map { SteamwarUser.get(it.uniqueId)!!.getId() },
-            plugin.server.onlinePlayers.filter {! blueTeam.members.contains(it) && !redTeam.members.contains(it) }.map { SteamwarUser.get(it.uniqueId).id }
+            plugin.server.onlinePlayers.filter {! blueTeam.members.contains(it) && !redTeam.members.contains(it) }.map { SteamwarUser.get(it.uniqueId)!!.getId() }
         ))
     }
 

VelocityCore/src/de/steamwar/messages/Chatter.java

@@ -201,7 +201,7 @@ public interface Chatter {
         return new PlayerlessChatter() {
             @Override
             public SteamwarUser user() {
-                return SteamwarUser.get(-1);
+                return SteamwarUser.byId(-1);
             }
 
             @Override

VelocityCore/src/de/steamwar/velocitycore/commands/BauCommand.java

@@ -33,7 +33,6 @@ import de.steamwar.messages.PlayerChatter;
 import de.steamwar.network.packets.server.BaumemberUpdatePacket;
 import de.steamwar.persistent.Bauserver;
 import de.steamwar.sql.BauweltMember;
-import de.steamwar.sql.SchematicType;
 import de.steamwar.sql.SteamwarUser;
 import de.steamwar.velocitycore.*;
 import de.steamwar.velocitycore.inventory.SWInventory;
@@ -198,7 +197,7 @@ public class BauCommand extends SWCommand {
             @Override
             public Collection<String> tabCompletes(Chatter sender, PreviousArguments previousArguments, String s) {
                 return BauweltMember.getMembers(sender.user().getId()).stream()
-                        .map(bauweltMember -> SteamwarUser.get(bauweltMember.getMemberID()).getUserName())
+                        .map(bauweltMember -> SteamwarUser.byId(bauweltMember.getMemberID()).getUserName())
                         .toList();
             }
         };

VelocityCore/src/de/steamwar/velocitycore/commands/CheckCommand.java

@@ -106,13 +106,13 @@ public class CheckCommand extends SWCommand {
                         new Message("CHECK_LIST_TO_CHECK_HOVER"),
                         ClickEvent.runCommand("/check schematic " + schematic.getId()),
                         getWaitTime(schematic),
-                        schematic.getSchemtype().getKuerzel(), SteamwarUser.get(schematic.getOwner()).getUserName(), schematic.getName());
+                        schematic.getSchemtype().getKuerzel(), SteamwarUser.byId(schematic.getOwner()).getUserName(), schematic.getName());
             } else {
                 sender.prefixless("CHECK_LIST_CHECKING",
                         new Message("CHECK_LIST_CHECKING_HOVER"),
                         ClickEvent.runCommand("/join " + current.checker.user().getUserName()),
                         getWaitTime(schematic),
-                        schematic.getSchemtype().getKuerzel(), SteamwarUser.get(schematic.getOwner()).getUserName(), schematic.getName(), current.checker.user().getUserName());
+                        schematic.getSchemtype().getKuerzel(), SteamwarUser.byId(schematic.getOwner()).getUserName(), schematic.getName(), current.checker.user().getUserName());
             }
         }
     }
@@ -135,7 +135,7 @@ public class CheckCommand extends SWCommand {
 
         int playerTeam = sender.user().hasPerm(UserPerm.MODERATION) ? 0 : sender.user().getTeam();
         // Ignore 795 SteamWar Team
-        if (playerTeam != 0 && playerTeam != 795 && SteamwarUser.get(schem.getOwner()).getTeam() == playerTeam) {
+        if (playerTeam != 0 && playerTeam != 795 && SteamwarUser.byId(schem.getOwner()).getTeam() == playerTeam) {
             sender.system("CHECK_SCHEMATIC_OWN_TEAM");
             return;
         }
@@ -228,7 +228,7 @@ public class CheckCommand extends SWCommand {
                 currentSchems.put(schematic.getId(), this);
 
                 for(CheckedSchematic previous : CheckedSchematic.previousChecks(schematic))
-                    checker.prefixless("CHECK_SCHEMATIC_PREVIOUS", previous.getEndTime(), SteamwarUser.get(previous.getValidator()).getUserName(), previous.getDeclineReason());
+                    checker.prefixless("CHECK_SCHEMATIC_PREVIOUS", previous.getEndTime(), SteamwarUser.byId(previous.getValidator()).getUserName(), previous.getDeclineReason());
                 next();
             }).start();
         }
@@ -277,7 +277,7 @@ public class CheckCommand extends SWCommand {
 
         private void accept(){
             concludeCheckSession("freigegeben", fightTypes.get(schematic.getSchemtype()), () -> {
-                Chatter owner = Chatter.of(SteamwarUser.get(schematic.getOwner()).getUUID());
+                Chatter owner = Chatter.of(SteamwarUser.byId(schematic.getOwner()).getUUID());
                 owner.withPlayerOrOffline(
                         player -> owner.system("CHECK_ACCEPTED", schematic.getSchemtype().name(), schematic.getName()),
                         () -> DiscordAlert.send(owner, Color.GREEN, new Message("DC_TITLE_SCHEMINFO"), new Message("DC_SCHEM_ACCEPT", schematic.getName()), true)
@@ -290,7 +290,7 @@ public class CheckCommand extends SWCommand {
 
         private void decline(String reason){
             concludeCheckSession(reason, SchematicType.Normal, () -> {
-                Chatter owner = Chatter.of(SteamwarUser.get(schematic.getOwner()).getUUID());
+                Chatter owner = Chatter.of(SteamwarUser.byId(schematic.getOwner()).getUUID());
                 owner.withPlayerOrOffline(
                         player -> owner.system("CHECK_DECLINED", schematic.getSchemtype().name(), schematic.getName(), reason),
                         () -> DiscordAlert.send(owner, Color.RED, new Message("DC_TITLE_SCHEMINFO"), new Message("DC_SCHEM_DECLINE", schematic.getName(), reason), false)

VelocityCore/src/de/steamwar/velocitycore/commands/PunishmentCommand.java

@@ -92,7 +92,7 @@ public class PunishmentCommand {
             String ip = IPSanitizer.getTrueAddress(player).getHostAddress();
             Chatter.disconnect(player).system(punishmentMessage(user, Punishment.PunishmentType.Ban));
             for (BannedUserIPs banned : BannedUserIPs.get(ip)) {
-                SteamwarUser bannedUser = SteamwarUser.get(banned.getUserID());
+                SteamwarUser bannedUser = SteamwarUser.byId(banned.getUserID());
                 if (bannedUser.isPunished(Punishment.PunishmentType.Ban) && bannedUser.getPunishment(Punishment.PunishmentType.Ban).getEndTime().before(time)) {
                     bannedUser.punish(Punishment.PunishmentType.Ban, time, banReason, punisher.getId(), perma);
                 }

VelocityCore/src/de/steamwar/velocitycore/commands/TeamCommand.java

@@ -240,7 +240,7 @@ public class TeamCommand extends SWCommand {
             @Override
             public Collection<String> tabCompletes(Chatter sender, PreviousArguments previousArguments, String s) {
                 return Team.get(sender.user().getTeam()).getMembers().stream()
-                        .map(SteamwarUser::get)
+                        .map(SteamwarUser::byId)
                         .map(SteamwarUser::getUserName)
                         .toList();
             }
@@ -296,7 +296,7 @@ public class TeamCommand extends SWCommand {
 
     @Register(value = "info", description = "TEAM_INFO_USAGE")
     public void info(Chatter sender, @ErrorMessage("UNKNOWN_TEAM") Team team){
-        List<SteamwarUser> users = team.getMembers().stream().map(SteamwarUser::get).toList();
+        List<SteamwarUser> users = team.getMembers().stream().map(SteamwarUser::byId).toList();
 
         sender.system("TEAM_INFO_TEAM", team.getTeamName(), team.getTeamColor(), team.getTeamKuerzel());
         sender.prefixless("TEAM_INFO_LEADER", users.stream().filter(SteamwarUser::isLeader).count(), getMemberList(users, true));

VelocityCore/src/de/steamwar/velocitycore/commands/WhoisCommand.java

@@ -56,7 +56,7 @@ public class WhoisCommand extends SWCommand {
         }
 
         // SW ID or Discord ID
-        whois(sender, id < Integer.MAX_VALUE ? SteamwarUser.get((int) id) : SteamwarUser.get(id), parameters);
+        whois(sender, id < Integer.MAX_VALUE ? SteamwarUser.byId((int) id) : SteamwarUser.get(id), parameters);
     }
 
     @Register(description = "WHOIS_USAGE")
@@ -128,7 +128,7 @@ public class WhoisCommand extends SWCommand {
             if (!all && !punishment.isCurrent()) {
                 continue;
             }
-            sender.prefixless("WHOIS_PUNISHMENT", SteamwarUser.get(punishment.getPunisher()), punishment.getType().name(), duration(sender, punishment.getStartTime(), false), duration(sender, punishment.getEndTime(), punishment.isPerma()), punishment.getReason());
+            sender.prefixless("WHOIS_PUNISHMENT", SteamwarUser.byId(punishment.getPunisher()), punishment.getType().name(), duration(sender, punishment.getStartTime(), false), duration(sender, punishment.getEndTime(), punishment.isPerma()), punishment.getReason());
             isPunished = true;
         }
         if (!isPunished) {

VelocityCore/src/de/steamwar/velocitycore/discord/channels/ChecklistChannel.java

@@ -23,7 +23,6 @@ import de.steamwar.sql.SchematicNode;
 import de.steamwar.sql.SteamwarUser;
 import de.steamwar.velocitycore.commands.CheckCommand;
 
-import java.time.Instant;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -43,7 +42,7 @@ public class ChecklistChannel extends DiscordChannel {
 
        for(SchematicNode schem : schems) {
            String waitTime = "<t:" + (schem.getLastUpdate().getTime() / 1000) + ":R>";
-           system("CHECK_LIST_TO_CHECK", waitTime, schem.getSchemtype().getKuerzel(), SteamwarUser.get(schem.getOwner()).getUserName(), schem.getName());
+           system("CHECK_LIST_TO_CHECK", waitTime, schem.getSchemtype().getKuerzel(), SteamwarUser.byId(schem.getOwner()).getUserName(), schem.getName());
            lastSchematics.add(schem.getId());
        }
     }

VelocityCore/src/de/steamwar/velocitycore/discord/channels/DiscordChannel.java

@@ -47,7 +47,7 @@ public class DiscordChannel extends Chatter.PlayerlessChatter {
 
     public static SteamwarUser userOrPublic(User dcUser) {
         SteamwarUser user = SteamwarUser.get(dcUser.getIdLong());
-        return user != null ? user : SteamwarUser.get(0);
+        return user != null ? user : SteamwarUser.byId(0);
     }
 
     private final Queue<Webhook> webhooks = new ArrayDeque<>();
@@ -67,7 +67,7 @@ public class DiscordChannel extends Chatter.PlayerlessChatter {
     }
 
     public DiscordChannel(MessageChannel channel, int maxNumberOfWebhooks) {
-        this(SteamwarUser.get(-1), channel, maxNumberOfWebhooks);
+        this(SteamwarUser.byId(-1), channel, maxNumberOfWebhooks);
         ChannelListener.getChannels().put(this.channel, this);
 
         if (channel instanceof TextChannel) {

VelocityCore/src/de/steamwar/velocitycore/listeners/BanListener.java

@@ -56,7 +56,7 @@ public class BanListener extends BasicListener {
             Timestamp highestBan = ips.get(0).getTimestamp();
             boolean perma = false;
             for(BannedUserIPs banned : ips) {
-                SteamwarUser bannedUser = SteamwarUser.get(banned.getUserID());
+                SteamwarUser bannedUser = SteamwarUser.byId(banned.getUserID());
                 if (bannedUser.isPunished(Punishment.PunishmentType.Ban)) {
                     Punishment ban = bannedUser.getPunishment(Punishment.PunishmentType.Ban);
                     if(ban.isPerma()) {
@@ -77,7 +77,7 @@ public class BanListener extends BasicListener {
                     clickEvent,
                     user.getUserName(),
                     (Function<Chatter, String>) ((Chatter sender) -> ips.stream().map(banned -> {
-                        SteamwarUser bannedUser = SteamwarUser.get(banned.getUserID());
+                        SteamwarUser bannedUser = SteamwarUser.byId(banned.getUserID());
                         return sender.parseToLegacy("BAN_AVOIDING_LIST", bannedUser.getUserName(),
                                 banned.getTimestamp().toLocalDateTime().format(DateTimeFormatter.ofPattern(sender.parseToPlain("TIMEFORMAT"))));
                     }).collect(Collectors.joining(" ")))

VelocityCore/src/de/steamwar/velocitycore/listeners/ChatListener.java

@@ -90,7 +90,7 @@ public class ChatListener extends BasicListener {
                 user = SteamwarUser.get(player.getUniqueId());
                 name = player.getUsername();
             } else if (source instanceof ConsoleCommandSource) {
-                user = SteamwarUser.get(-1);
+                user = SteamwarUser.byId(-1);
                 name = "«CONSOLE»";
             } else {
                 name = source.toString();
@@ -128,7 +128,7 @@ public class ChatListener extends BasicListener {
 
         SteamwarUser user = SteamwarUser.get(player.getUniqueId());
         if (message.contains("jndi:ldap")) {
-            PunishmentCommand.ban(user, Punishment.PERMA_TIME, "Versuchte Exploit-Ausnutzung", SteamwarUser.get(-1), true);
+            PunishmentCommand.ban(user, Punishment.PERMA_TIME, "Versuchte Exploit-Ausnutzung", SteamwarUser.byId(-1), true);
             VelocityCore.getLogger().log(Level.SEVERE,  "%s %s wurde automatisch wegen jndi:ldap gebannt.".formatted(user.getUserName(), user.getId()));
             return;
         }

VelocityCore/src/de/steamwar/velocitycore/mods/ModUtils.java

@@ -83,7 +83,7 @@ public class ModUtils {
 
         if(max == ModType.RED) {
             user.punish(Punishment.PunishmentType.Ban, Timestamp.from(Instant.now().plus(7, ChronoUnit.DAYS)), message, -1, false);
-            PunishmentCommand.ban(user, Timestamp.from(Instant.now().plus(7, ChronoUnit.DAYS)), message, SteamwarUser.get(-1), false);
+            PunishmentCommand.ban(user, Timestamp.from(Instant.now().plus(7, ChronoUnit.DAYS)), message, SteamwarUser.byId(-1), false);
             VelocityCore.getLogger().log(Level.SEVERE, "%s %s wurde automatisch wegen der Mods %s gebannt.".formatted(user.getUserName(), user.getId(), modList));
         }
 

VelocityCore/src/de/steamwar/velocitycore/network/handlers/EloPlayerHandler.java

@@ -70,9 +70,9 @@ public class EloPlayerHandler extends PacketHandler {
 
         // Die nächsten Zeilen filtern ein Fight innerhalb eines Teams nicht gewertet wird, bzw auch wenn nur Teile beider Teams im
         // gleichen Team sind dieser ungewertet ist.
-        Set<Integer> teamsIds = fightEndsPacket.getBluePlayers().stream().map(SteamwarUser::get).map(SteamwarUser::getTeam).collect(Collectors.toSet());
+        Set<Integer> teamsIds = fightEndsPacket.getBluePlayers().stream().map(SteamwarUser::byId).map(SteamwarUser::getTeam).collect(Collectors.toSet());
         for (int redPlayer : fightEndsPacket.getRedPlayers()) {
-            int team = SteamwarUser.get(redPlayer).getTeam();
+            int team = SteamwarUser.byId(redPlayer).getTeam();
             if (team != 0 && teamsIds.contains(team)) {
                 return;
             }
@@ -214,7 +214,7 @@ public class EloPlayerHandler extends PacketHandler {
     }
 
     private Player player(int userId) {
-        return VelocityCore.getProxy().getPlayer(SteamwarUser.get(userId).getUUID()).orElse(null);
+        return VelocityCore.getProxy().getPlayer(SteamwarUser.byId(userId).getUUID()).orElse(null);
     }
 
     private double getTimeFactor(int duration) {

VelocityCore/src/de/steamwar/velocitycore/network/handlers/ExecuteCommandHandler.java

@@ -30,7 +30,7 @@ public class ExecuteCommandHandler extends PacketHandler {
 
     @Handler
     public void handle(ExecuteCommandPacket packet) {
-        SteamwarUser target = SteamwarUser.get(packet.getPlayerId());
+        SteamwarUser target = SteamwarUser.byId(packet.getPlayerId());
         String command = packet.getCommand();
 
         VelocityCore.getProxy().getCommandManager().executeAsync(VelocityCore.getProxy().getPlayer(target.getUUID()).orElse(null), command);

VelocityCore/src/de/steamwar/velocitycore/network/handlers/InventoryCallbackHandler.java

@@ -41,7 +41,7 @@ public class InventoryCallbackHandler extends PacketHandler {
 
     @Handler
     public void handle(InventoryCallbackPacket packet) {
-        SteamwarUser owner = SteamwarUser.get(packet.getOwner());
+        SteamwarUser owner = SteamwarUser.byId(packet.getOwner());
         InventoryCallbackPacket.CallbackType type = packet.getType();
         if(!inventoryHashMap.containsKey(owner.getId())) {
             Chatter.of(owner).system("UPDATE_INTERRUPTION");

VelocityCore/src/de/steamwar/velocitycore/network/handlers/PrepareSchemHandler.java

@@ -35,7 +35,7 @@ public class PrepareSchemHandler extends PacketHandler {
 
     @Handler
     public void handle(PrepareSchemPacket packet) {
-        Player player = VelocityCore.getProxy().getPlayer(SteamwarUser.get(packet.getPlayer()).getUUID()).orElse(null);
+        Player player = VelocityCore.getProxy().getPlayer(SteamwarUser.byId(packet.getPlayer()).getUUID()).orElse(null);
         int schematicID = packet.getSchem();
         GameModeConfig<String, String> mode = ArenaMode.getBySchemType(SchematicType.fromDB(packet.getSchemType()));
 

VelocityCore/src/de/steamwar/velocitycore/tablist/TablistServer.java

@@ -80,7 +80,7 @@ public class TablistServer implements TablistPart {
     }
 
     private void addPlayers(String prefix, List<Integer> teamPlayers, Collection<Player> onlinePlayers) {
-        teamPlayers.stream().map(SteamwarUser::get).map(
+        teamPlayers.stream().map(SteamwarUser::byId).map(
                 user -> onlinePlayers.stream().filter(player -> player.getUniqueId().equals(user.getUUID())).findAny()
         ).filter(Optional::isPresent).map(Optional::get).sorted(
                 (p1, p2) -> p1.getUsername().compareToIgnoreCase(p2.getUsername())

WebsiteBackend/src/de/steamwar/plugins/Auth.kt

@@ -75,7 +75,7 @@ val SWPermissionCheck = createRouteScopedPlugin("SWAuth", ::SWAuthConfig) {
                 return@on
             }
 
-            if (permission != null && !token.user.hasPerm(permission)) {
+            if (permission != null && !token.user.hasPerm(permission!!)) {
                 call.respond(HttpStatusCode.Forbidden)
                 return@on
             }

WebsiteBackend/src/de/steamwar/routes/Data.kt

@@ -46,7 +46,7 @@ data class ResponseSchematicType(val name: String, val db: String)
 data class ResponseUser(val name: String, val uuid: String, val prefix: String, val perms: List<String>) {
     constructor(user: SteamwarUser) : this(user.userName, user.uuid.toString(), user.prefix().chatPrefix, user.perms().filter { !it.name.startsWith("PREFIX_") }.map { it.name }) {
         synchronized(cache) {
-            cache[user.id] = this
+            cache[user.getId()] = this
         }
     }
 
@@ -55,7 +55,7 @@ data class ResponseUser(val name: String, val uuid: String, val prefix: String,
 
         fun get(id: Int): ResponseUser {
             synchronized(cache) {
-                return cache[id] ?: ResponseUser(SteamwarUser.get(id)).also { cache[id] = it }
+                return cache[id] ?: ResponseUser(SteamwarUser.byId(id)!!).also { cache[id] = it }
             }
         }
 
@@ -75,7 +75,7 @@ fun Route.configureDataRoutes() {
                 permission = UserPerm.MODERATION
             }
             get("/users") {
-                call.respond(SteamwarUser.getAll().map { ResponseUser(it) })
+                call.respond(SteamwarUser.all().map { ResponseUser(it) })
             }
             get("/teams") {
                 call.respond(Team.getAll().map { ResponseTeam(it) })

WebsiteBackend/src/de/steamwar/routes/EventReferees.kt

@@ -21,7 +21,6 @@ package de.steamwar.routes
 
 import de.steamwar.sql.Referee
 import de.steamwar.sql.SteamwarUser
-import io.ktor.http.*
 import io.ktor.server.application.*
 import io.ktor.server.request.*
 import io.ktor.server.response.*
@@ -32,23 +31,23 @@ fun Route.configureEventRefereesRouting() {
     route("/referees") {
         get {
             val event = call.receiveEvent() ?: return@get
-            call.respond(Referee.get(event.eventID).map { ResponseUser(SteamwarUser.get(it)) })
+            call.respond(Referee.get(event.eventID).map { ResponseUser(SteamwarUser.byId(it)!!) })
         }
         put {
             val event = call.receiveEvent() ?: return@put
             val referees = call.receive<List<String>>()
             referees.forEach {
-                Referee.add(event.eventID, SteamwarUser.get(UUID.fromString(it)).id)
+                Referee.add(event.eventID, SteamwarUser.get(UUID.fromString(it))!!.getId())
             }
-            call.respond(Referee.get(event.eventID).map { ResponseUser(SteamwarUser.get(it)) })
+            call.respond(Referee.get(event.eventID).map { ResponseUser(SteamwarUser.byId(it)!!) })
         }
         delete {
             val event = call.receiveEvent() ?: return@delete
             val referees = call.receive<List<String>>()
             referees.forEach {
-                Referee.remove(event.eventID, SteamwarUser.get(UUID.fromString(it)).id)
+                Referee.remove(event.eventID, SteamwarUser.get(UUID.fromString(it))!!.getId())
             }
-            call.respond(Referee.get(event.eventID).map { ResponseUser(SteamwarUser.get(it)) })
+            call.respond(Referee.get(event.eventID).map { ResponseUser(SteamwarUser.byId(it)!!) })
         }
     }
 }

WebsiteBackend/src/de/steamwar/routes/Events.kt

@@ -118,7 +118,7 @@ data class ExtendedResponseEvent(
         TeamTeilnahme.getTeams(event.eventID).map { ResponseTeam(it) },
         EventGroup.get(event).map { ResponseGroups(it) },
         EventFight.getEvent(event.eventID).map { ResponseEventFight(it) },
-        Referee.get(event.eventID).map { ResponseUser(SteamwarUser.get(it)) },
+        Referee.get(event.eventID).map { ResponseUser(SteamwarUser.byId(it)!!) },
         EventRelation.get(event).map { ResponseRelation(it) }
     )
 }
@@ -221,13 +221,13 @@ fun Route.configureEventsRoute() {
 
                 if (updateEvent.addReferee != null) {
                     updateEvent.addReferee.forEach {
-                        Referee.add(event.eventID, SteamwarUser.get(UUID.fromString(it)).id)
+                        Referee.add(event.eventID, SteamwarUser.get(UUID.fromString(it))!!.getId())
                     }
                 }
 
                 if (updateEvent.removeReferee != null) {
                     updateEvent.removeReferee.forEach {
-                        Referee.remove(event.eventID, SteamwarUser.get(UUID.fromString(it)).id)
+                        Referee.remove(event.eventID, SteamwarUser.get(UUID.fromString(it))!!.getId())
                     }
                 }
                 event.update(eventName, deadline, start, end, schemType, maxTeamMembers, publicSchemsOnly)

WebsiteBackend/src/de/steamwar/routes/Schematic.kt

@@ -128,9 +128,9 @@ fun Route.configureSchematic() {
 
             val user = call.principal<SWAuthPrincipal>()!!.user
 
-            var node = SchematicNode.getSchematicNode(user.id, schemName, null as Int?)
+            var node = SchematicNode.getSchematicNode(user.getId(), schemName, null as Int?)
             if (node == null) {
-                node = SchematicNode.createSchematic(user.id, schemName, null)
+                node = SchematicNode.createSchematic(user.getId(), schemName, null)
             }
 
             try {

WebsiteBackend/src/de/steamwar/routes/Stats.kt

@@ -36,7 +36,7 @@ data class UserStats(val eventFightParticipation: Int, val eventParticipation: I
         getEventParticipation(user) ?: 0,
         getAcceptedSchematics(user) ?: 0,
         getFightCount(user) ?: 0,
-        user.onlinetime / 3600.0
+        user.getOnlinetime() / 3600.0
     )
 }
 

settings.gradle.kts

@@ -166,6 +166,12 @@ dependencyResolutionManagement {
             library("ktorRateLimit", "io.ktor:ktor-server-rate-limit:$ktorVersion")
 
             library("nbt", "dev.dewy:nbt:1.5.1")
+
+            val exposedVersion = "1.0.0-rc-2"
+            library("exposedCore", "org.jetbrains.exposed:exposed-core:$exposedVersion")
+            library("exposedDao", "org.jetbrains.exposed:exposed-dao:$exposedVersion")
+            library("exposedJdbc", "org.jetbrains.exposed:exposed-jdbc:$exposedVersion")
+            library("exposedTime", "org.jetbrains.exposed:exposed-java-time:$exposedVersion")
         }
     }
 }