Format code

CommonCore/Linkage/src/de/steamwar/linkage/PluginCheck.java

@@ -26,6 +26,7 @@ import java.lang.annotation.*;
 @Repeatable(PluginCheck.PluginChecks.class)
 public @interface PluginCheck {
     Has has() default Has.THIS;
+
     String value();
 
     enum Has {

CommonCore/Network/src/de/steamwar/network/packets/PacketHandler.java

@@ -44,7 +44,7 @@ public abstract class PacketHandler {
     protected PacketHandler() {
         Method[] methods = getClass().getMethods();
         for (Method method : methods) {
-            if(method.getParameterCount() != 1 || !NetworkPacket.class.isAssignableFrom(method.getParameterTypes()[0])) {
+            if (method.getParameterCount() != 1 || !NetworkPacket.class.isAssignableFrom(method.getParameterTypes()[0])) {
                 continue;
             }
 
@@ -73,5 +73,6 @@ public abstract class PacketHandler {
     }
 
     @Retention(RetentionPolicy.RUNTIME)
-    protected @interface Handler {}
+    protected @interface Handler {
+    }
 }

CommonCore/Network/testsrc/de/steamwar/RandomGenerator.java

@@ -70,7 +70,7 @@ public class RandomGenerator {
     }
 
     public static <T> T generateRandom(Class<T> clazz) {
-        if(clazz.isEnum()) {
+        if (clazz.isEnum()) {
             return generateRandomEnum(clazz);
         } else {
             return (T) generators.get(clazz).apply(clazz);

CommonCore/SQL/src/de/steamwar/ImplementationProvider.java

@@ -22,12 +22,14 @@ package de.steamwar;
 import java.lang.reflect.InvocationTargetException;
 
 public class ImplementationProvider {
-    private ImplementationProvider() {}
+    private ImplementationProvider() {
+    }
 
     public static <T> T getImpl(String className) {
         try {
             return (T) Class.forName(className).getDeclaredConstructor().newInstance();
-        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException | ClassNotFoundException e) {
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException |
+                 ClassNotFoundException e) {
             throw new SecurityException("Could not load implementation", e);
         }
     }

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

@@ -27,7 +27,7 @@ import org.jetbrains.exposed.v1.dao.IntEntityClass
 import org.jetbrains.exposed.v1.javatime.timestamp
 import java.time.Instant
 
-object AuditLogTable: IntIdTable("AuditLog", "AuditLogId") {
+object AuditLogTable : IntIdTable("AuditLog", "AuditLogId") {
     val time = timestamp("Time").index()
     val server = varchar("ServerName", 255).index()
     val serverOwner = reference("ServerOwner", SteamwarUserTable).nullable().index()
@@ -36,8 +36,8 @@ object AuditLogTable: IntIdTable("AuditLog", "AuditLogId") {
     val actionText = text("ActionText")
 }
 
-class AuditLog(id: EntityID<Int>): IntEntity(id) {
-    companion object: IntEntityClass<AuditLog>(AuditLogTable) {
+class AuditLog(id: EntityID<Int>) : IntEntity(id) {
+    companion object : IntEntityClass<AuditLog>(AuditLogTable) {
         const val SERVER_NAME_VELOCITY: String = "Velocity"
 
         private fun create(
@@ -46,25 +46,29 @@ class AuditLog(id: EntityID<Int>): IntEntity(id) {
             actor: SteamwarUser,
             actionType: Type,
             text: String = ""
-        ) = useDb {
-            new {
-                this.time = Instant.now()
-                this.server = serverName
-                this.serverOwner = serverOwner?.id
-                this.actor = actor.id
-                this.action = actionType
-                this.actionText = text
+        ) =
+            useDb {
+                new {
+                    this.time = Instant.now()
+                    this.server = serverName
+                    this.serverOwner = serverOwner?.id
+                    this.actor = actor.id
+                    this.action = actionType
+                    this.actionText = text
+                }
             }
-        }
 
         @JvmStatic
-        fun createJoin(jointServerName: String, serverOwner: SteamwarUser?, joinedPlayer: SteamwarUser) = create(jointServerName, serverOwner, joinedPlayer, Type.JOIN)
+        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)
+        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) }
+        fun createCommand(serverName: String, serverOwner: SteamwarUser?, player: SteamwarUser?, command: String) =
+            player?.let { create(serverName, serverOwner, it, Type.COMMAND, command) }
 
         @JvmStatic
         fun createSensitiveCommand(
@@ -72,13 +76,16 @@ class AuditLog(id: EntityID<Int>): IntEntity(id) {
             serverOwner: SteamwarUser?,
             player: SteamwarUser?,
             command: String
-        ) = player?.let { create(serverName, serverOwner, it, Type.SENSITIVE_COMMAND, command) }
+        ) =
+            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)
+        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)
+        fun createGuiOpen(serverName: String, serverOwner: SteamwarUser?, player: SteamwarUser, guiName: String) =
+            create(serverName, serverOwner, player, Type.GUI_OPEN, guiName)
 
         @JvmStatic
         fun createGuiClick(
@@ -89,16 +96,18 @@ class AuditLog(id: EntityID<Int>): IntEntity(id) {
             clickType: String,
             slot: Int,
             itemName: String
-        ) = create(
-            serverName,
-            serverOwner,
-            player,
-            Type.GUI_CLICK,
-            "Gui: $guiName\nSlot: $slot\nClickType: $clickType\nItemName: $itemName"
-        )
+        ) =
+            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)
+        fun createGuiClose(serverName: String, serverOwner: SteamwarUser?, player: SteamwarUser, guiName: String) =
+            create(serverName, serverOwner, player, Type.GUI_CLOSE, guiName)
     }
 
     var time by AuditLogTable.time

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

@@ -32,7 +32,7 @@ import org.jetbrains.exposed.v1.jdbc.insertIgnore
 import java.sql.Timestamp
 import java.time.Instant
 
-object BannedUserIPsTable: CompositeIdTable("BannedUserIPs") {
+object BannedUserIPsTable : CompositeIdTable("BannedUserIPs") {
     val userId = reference("UserID", SteamwarUserTable).index()
     val timestamp = timestamp("Timestamp").index()
     val ip = varchar("IP", 45).entityId()
@@ -44,39 +44,44 @@ object BannedUserIPsTable: CompositeIdTable("BannedUserIPs") {
     override val primaryKey = PrimaryKey(userId, ip)
 }
 
-class BannedUserIPs(id: EntityID<CompositeID>): CompositeEntity(id) {
-    companion object: CompositeEntityClass<BannedUserIPs>(BannedUserIPsTable) {
+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()
+        fun get(userId: Int) =
+            useDb {
+                find { BannedUserIPsTable.userId eq userId }.toList()
             }
-        }
 
         @JvmStatic
-        fun unbanIPs(userId: Int) = useDb {
-            BannedUserIPsTable.deleteWhere { BannedUserIPsTable.userId eq userId }
-        }
+        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()
-    }
+    fun remove() =
+        useDb {
+            delete()
+        }
 }

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

@@ -31,7 +31,7 @@ import org.jetbrains.exposed.v1.dao.CompositeEntityClass
 import org.jetbrains.exposed.v1.jdbc.insertIgnore
 import java.util.*
 
-object BauweltMemberTable: CompositeIdTable("BauweltMember") {
+object BauweltMemberTable : CompositeIdTable("BauweltMember") {
     val bauweltId = reference("BauweltID", SteamwarUserTable).index()
     val memberId = reference("MemberID", SteamwarUserTable).index()
     val build = bool("Build")
@@ -46,51 +46,60 @@ object BauweltMemberTable: CompositeIdTable("BauweltMember") {
     }
 }
 
-class BauweltMember(id: EntityID<CompositeID>): CompositeEntity(id) {
-    companion object: CompositeEntityClass<BauweltMember>(BauweltMemberTable) {
+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)
+        private fun cache(member: BauweltMember) =
+            cache.put(member.memberID, member)
 
         @JvmStatic
-        fun clear() = cache.clear()
+        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)
+        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: 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
+        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) }
-        }
+        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) }
-        }
+        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)
+        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) } }
-        }
+        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 })
@@ -119,12 +128,20 @@ class BauweltMember(id: EntityID<CompositeID>): CompositeEntity(id) {
             world = value
         }
 
-    fun isBuild() = build
-    fun isSupervisor() = world
-    fun isWorldEdit() = build
-    fun isWorld() = world
+    fun isBuild() =
+        build
 
-    fun remove() = useDb {
-        delete()
-    }
+    fun isSupervisor() =
+        world
+
+    fun isWorldEdit() =
+        build
+
+    fun isWorld() =
+        world
+
+    fun remove() =
+        useDb {
+            delete()
+        }
 }

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

@@ -30,7 +30,7 @@ import org.jetbrains.exposed.v1.javatime.timestamp
 import org.jetbrains.exposed.v1.jdbc.insertIgnore
 import java.sql.Timestamp
 
-object CheckedSchematicTable: CompositeIdTable("CheckedSchematic") {
+object CheckedSchematicTable : CompositeIdTable("CheckedSchematic") {
     val nodeId = optReference("NodeId", SchematicNodeTable, onDelete = ReferenceOption.SET_NULL, onUpdate = ReferenceOption.SET_NULL).index()
     val nodeOwner = reference("NodeOwner", SteamwarUserTable).index()
     val nodeName = varchar("NodeName", 64).entityId().index()
@@ -51,37 +51,41 @@ object CheckedSchematicTable: CompositeIdTable("CheckedSchematic") {
     }
 }
 
-class CheckedSchematic(id: EntityID<CompositeID>): CompositeEntity(id) {
-    companion object: CompositeEntityClass<CheckedSchematic>(CheckedSchematicTable) {
+class CheckedSchematic(id: EntityID<CompositeID>) : CompositeEntity(id) {
+    companion object : CompositeEntityClass<CheckedSchematic>(CheckedSchematicTable) {
         @JvmStatic
-        fun create(node: SchematicNode, validator: Int, startTime: Timestamp, endTime: Timestamp, reason: String, seen: Boolean) = useDb {
-            CheckedSchematicTable.insertIgnore {
-                it[this.nodeId] = node.id
-                it[this.nodeOwner] = EntityID(node.owner, SteamwarUserTable)
-                it[this.nodeName] = node.name
-                it[this.validator] = EntityID(validator, SteamwarUserTable)
-                it[this.startTime] = startTime.toInstant()
-                it[this.endTime] = endTime.toInstant()
-                it[this.declineReason] = reason
-                it[this.seen] = seen
-                it[this.nodeType] = node.schemtype.toDB().substring(1)
+        fun create(node: SchematicNode, validator: Int, startTime: Timestamp, endTime: Timestamp, reason: String, seen: Boolean) =
+            useDb {
+                CheckedSchematicTable.insertIgnore {
+                    it[this.nodeId] = node.id
+                    it[this.nodeOwner] = EntityID(node.owner, SteamwarUserTable)
+                    it[this.nodeName] = node.name
+                    it[this.validator] = EntityID(validator, SteamwarUserTable)
+                    it[this.startTime] = startTime.toInstant()
+                    it[this.endTime] = endTime.toInstant()
+                    it[this.declineReason] = reason
+                    it[this.seen] = seen
+                    it[this.nodeType] = node.schemtype.toDB().substring(1)
+                }
             }
-        }
 
         @JvmStatic
-        fun getLastDeclinedOfNode(node: Int) = useDb {
-            find { (CheckedSchematicTable.nodeId eq node) and (CheckedSchematicTable.declineReason neq "Prüfvorgang abgebrochen") }.orderBy(CheckedSchematicTable.endTime to SortOrder.DESC).toList()
-        }
+        fun getLastDeclinedOfNode(node: Int) =
+            useDb {
+                find { (CheckedSchematicTable.nodeId eq node) and (CheckedSchematicTable.declineReason neq "Prüfvorgang abgebrochen") }.orderBy(CheckedSchematicTable.endTime to SortOrder.DESC).toList()
+            }
 
         @JvmStatic
-        fun previousChecks(node: SchematicNode) = useDb {
-            find { (CheckedSchematicTable.nodeId eq node.id) and (CheckedSchematicTable.declineReason neq "") and (CheckedSchematicTable.declineReason neq "Prüfvorgang abgebrochen") }.orderBy(CheckedSchematicTable.endTime to SortOrder.DESC).toList()
-        }
+        fun previousChecks(node: SchematicNode) =
+            useDb {
+                find { (CheckedSchematicTable.nodeId eq node.id) and (CheckedSchematicTable.declineReason neq "") and (CheckedSchematicTable.declineReason neq "Prüfvorgang abgebrochen") }.orderBy(CheckedSchematicTable.endTime to SortOrder.DESC).toList()
+            }
 
         @JvmStatic
-        fun getUnseen(owner: SteamwarUser) = useDb {
-            find { (CheckedSchematicTable.nodeOwner eq owner.id) and (CheckedSchematicTable.seen eq false) }.orderBy(CheckedSchematicTable.endTime to SortOrder.DESC).toList()
-        }
+        fun getUnseen(owner: SteamwarUser) =
+            useDb {
+                find { (CheckedSchematicTable.nodeOwner eq owner.id) and (CheckedSchematicTable.seen eq false) }.orderBy(CheckedSchematicTable.endTime to SortOrder.DESC).toList()
+            }
     }
 
     val node by CheckedSchematicTable.nodeId.transform({ it?.let { EntityID(it, SchematicNodeTable) } }, { it?.value })

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

@@ -48,36 +48,42 @@ class Event(id: EntityID<Int>) : IntEntity(id) {
         private var current: Event? = null
 
         @JvmStatic
-        fun get(): Event? = if (current?.now() == true) {
-            current
-        } else useDb {
-            find { EventTable.start.lessEq(Instant.now()) and EventTable.end.greater(Instant.now()) }.firstOrNull()
-                ?.also { current == it }
-        }
+        fun get(): Event? =
+            if (current?.now() == true) {
+                current
+            } else useDb {
+                find { EventTable.start.lessEq(Instant.now()) and EventTable.end.greater(Instant.now()) }.firstOrNull()
+                    ?.also { current == it }
+            }
 
         @JvmStatic
-        fun getAll() = useDb { all().toList() }
+        fun getAll() =
+            useDb { all().toList() }
 
         @JvmStatic
-        fun create(name: String, start: Timestamp, end: Timestamp) = useDb {
-            EventTable.insertAndGetId {
-                it[this.name] = name
-                it[this.deadline] = start.toInstant()
-                it[this.start] = start.toInstant()
-                it[this.end] = end.toInstant()
-                it[this.maxPlayers] = 5
-                it[this.publicsOnly] = false
-            }.let { get(it) }
-        }
+        fun create(name: String, start: Timestamp, end: Timestamp) =
+            useDb {
+                EventTable.insertAndGetId {
+                    it[this.name] = name
+                    it[this.deadline] = start.toInstant()
+                    it[this.start] = start.toInstant()
+                    it[this.end] = end.toInstant()
+                    it[this.maxPlayers] = 5
+                    it[this.publicsOnly] = false
+                }.let { get(it) }
+            }
 
         @JvmStatic
-        fun byId(id: Int) = useDb { findById(id) }
+        fun byId(id: Int) =
+            useDb { findById(id) }
 
         @JvmStatic
-        fun get(name: String) = useDb { find { EventTable.name eq name }.firstOrNull() }
+        fun get(name: String) =
+            useDb { find { EventTable.name eq name }.firstOrNull() }
 
         @JvmStatic
-        fun getComing() = useDb { find { EventTable.start greater Instant.now() }.toList() }
+        fun getComing() =
+            useDb { find { EventTable.start greater Instant.now() }.toList() }
     }
 
     val eventID by EventTable.id.transform({ EntityID(it, EventTable) }, { it.value })
@@ -96,8 +102,11 @@ class Event(id: EntityID<Int>) : IntEntity(id) {
     var publicSchemsOnly by EventTable.publicsOnly
         private set
 
-    fun publicSchemsOnly() = publicSchemsOnly
-    fun now() = Instant.now().let { it.isAfter(start.toInstant()) && it.isBefore(end.toInstant()) }
+    fun publicSchemsOnly() =
+        publicSchemsOnly
+
+    fun now() =
+        Instant.now().let { it.isAfter(start.toInstant()) && it.isBefore(end.toInstant()) }
 
     fun update(
         name: String,
@@ -107,15 +116,17 @@ class Event(id: EntityID<Int>) : IntEntity(id) {
         schematicType: SchematicType?,
         maxPlayers: Int,
         publicSchemsOnly: Boolean
-    ) = useDb {
-        this@Event.eventName = name
-        this@Event.deadline = deadline
-        this@Event.start = start
-        this@Event.end = end
-        this@Event.maximumTeamMembers = maxPlayers
-        this@Event.schematicType = schematicType
-        this@Event.publicSchemsOnly = publicSchemsOnly
-    }
+    ) =
+        useDb {
+            this@Event.eventName = name
+            this@Event.deadline = deadline
+            this@Event.start = start
+            this@Event.end = end
+            this@Event.maximumTeamMembers = maxPlayers
+            this@Event.schematicType = schematicType
+            this@Event.publicSchemsOnly = publicSchemsOnly
+        }
 
-    override fun delete() = useDb { super.delete() }
+    override fun delete() =
+        useDb { super.delete() }
 }

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

@@ -52,31 +52,36 @@ class EventFight(id: EntityID<Int>) : IntEntity(id), Comparable<EventFight> {
             @JvmStatic get
 
         @JvmStatic
-        fun byId(fightId: Int) = useDb { findById(fightId) }
+        fun byId(fightId: Int) =
+            useDb { findById(fightId) }
 
         @JvmStatic
-        fun byId(group: EventGroup) = useDb {
-            find { EventFightTable.groupId eq group.id }.orderBy(EventFightTable.startTime to SortOrder.DESC).toList()
-        }
+        fun byId(group: EventGroup) =
+            useDb {
+                find { EventFightTable.groupId eq group.id }.orderBy(EventFightTable.startTime to SortOrder.DESC).toList()
+            }
 
         @JvmStatic
-        fun getLast(group: EventGroup) = useDb {
-            Optional.ofNullable(
-                find { EventFightTable.groupId eq group.id }.orderBy(EventFightTable.startTime to SortOrder.DESC)
-                    .firstOrNull()
-            )
-        }
+        fun getLast(group: EventGroup) =
+            useDb {
+                Optional.ofNullable(
+                    find { EventFightTable.groupId eq group.id }.orderBy(EventFightTable.startTime to SortOrder.DESC)
+                        .firstOrNull()
+                )
+            }
 
         @JvmStatic
-        fun loadAllComingFights() = useDb {
-            fights.clear()
-            fights.addAll(find { EventFightTable.startTime greaterEq Instant.now() }.orderBy(EventFightTable.startTime to SortOrder.ASC))
-        }
+        fun loadAllComingFights() =
+            useDb {
+                fights.clear()
+                fights.addAll(find { EventFightTable.startTime greaterEq Instant.now() }.orderBy(EventFightTable.startTime to SortOrder.ASC))
+            }
 
         @JvmStatic
-        fun getEvent(eventId: Int) = useDb {
-            find { EventFightTable.eventId eq eventId }.orderBy(EventFightTable.startTime to SortOrder.ASC).toList()
-        }
+        fun getEvent(eventId: Int) =
+            useDb {
+                find { EventFightTable.eventId eq eventId }.orderBy(EventFightTable.startTime to SortOrder.ASC).toList()
+            }
 
         private var activeFightsCache: List<EventFight>? = null
 
@@ -111,19 +116,20 @@ class EventFight(id: EntityID<Int>) : IntEntity(id), Comparable<EventFight> {
             blueTeam: Int,
             redTeam: Int,
             spectatePort: Int?
-        ) = useDb {
-            get(
-                EventFightTable.insertAndGetId {
-                    it[eventId] = EntityID(event, EventTable)
-                    it[startTime] = from.toInstant()
-                    it[gamemode] = spielmodus
-                    it[EventFightTable.map] = map
-                    it[teamBlue] = EntityID(blueTeam, TeamTable)
-                    it[teamRed] = EntityID(redTeam, TeamTable)
-                    it[EventFightTable.spectatePort] = spectatePort
-                }
-            )
-        }
+        ) =
+            useDb {
+                get(
+                    EventFightTable.insertAndGetId {
+                        it[eventId] = EntityID(event, EventTable)
+                        it[startTime] = from.toInstant()
+                        it[gamemode] = spielmodus
+                        it[EventFightTable.map] = map
+                        it[teamBlue] = EntityID(blueTeam, TeamTable)
+                        it[teamRed] = EntityID(redTeam, TeamTable)
+                        it[EventFightTable.spectatePort] = spectatePort
+                    }
+                )
+            }
     }
 
     val fightID by EventFightTable.id.transform({ EntityID(it, EventFightTable) }, { it.value })
@@ -155,16 +161,25 @@ class EventFight(id: EntityID<Int>) : IntEntity(id), Comparable<EventFight> {
     val losser: Team?
         get() = useDb { if (ergebnis == 1) Team[teamRed] else if (ergebnis == 2) Team[teamBlue] else null }
 
-    fun setGroup(group: Int?) = useDb { groupId = group?.let { EntityID(it, EventGroupTable) } }
-    fun hasFinished() = fight != null || ergebnis != 0
+    fun setGroup(group: Int?) =
+        useDb { groupId = group?.let { EntityID(it, EventGroupTable) } }
 
-    fun reschedule() = useDb {
-        startTime = Timestamp.from(Instant.now().plusSeconds(30))
-    }
+    fun hasFinished() =
+        fight != null || ergebnis != 0
 
-    override fun hashCode() = fightID
-    override fun equals(other: Any?) = other is EventFight && other.fightID == fightID
-    override fun compareTo(other: EventFight): Int = startTime.compareTo(other.startTime)
+    fun reschedule() =
+        useDb {
+            startTime = Timestamp.from(Instant.now().plusSeconds(30))
+        }
+
+    override fun hashCode() =
+        fightID
+
+    override fun equals(other: Any?) =
+        other is EventFight && other.fightID == fightID
+
+    override fun compareTo(other: EventFight): Int =
+        startTime.compareTo(other.startTime)
 
     fun update(
         startTime: Timestamp,
@@ -173,16 +188,18 @@ class EventFight(id: EntityID<Int>) : IntEntity(id), Comparable<EventFight> {
         teamBlue: Int,
         teamRed: Int,
         spectatePort: Int?
-    ) = useDb {
-        this@EventFight.startTime = startTime
-        this@EventFight.spielmodus = spielmodus
-        this@EventFight.map = map
-        this@EventFight.teamBlue = teamBlue
-        this@EventFight.teamRed = teamRed
-        this@EventFight.spectatePort = spectatePort
-    }
+    ) =
+        useDb {
+            this@EventFight.startTime = startTime
+            this@EventFight.spielmodus = spielmodus
+            this@EventFight.map = map
+            this@EventFight.teamBlue = teamBlue
+            this@EventFight.teamRed = teamRed
+            this@EventFight.spectatePort = spectatePort
+        }
 
-    override fun delete() = useDb {
-        super.delete()
-    }
+    override fun delete() =
+        useDb {
+            super.delete()
+        }
 }

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

@@ -44,19 +44,22 @@ class EventGroup(id: EntityID<Int>) : IntEntity(id) {
     companion object : IntEntityClass<EventGroup>(EventGroupTable) {
 
         @JvmStatic
-        fun get(event: Event) = useDb { find { EventGroupTable.event eq event.id }.toList() }
+        fun get(event: Event) =
+            useDb { find { EventGroupTable.event eq event.id }.toList() }
 
         @JvmStatic
-        fun byId(groupId: Int) = useDb { Optional.ofNullable(findById(groupId)) }
+        fun byId(groupId: Int) =
+            useDb { Optional.ofNullable(findById(groupId)) }
 
         @JvmStatic
-        fun create(event: Event, name: String, type: EventGroupType) = useDb {
-            new {
-                this.eventID = event.id.value
-                this.groupName = name
-                this.groupType = type
+        fun create(event: Event, name: String, type: EventGroupType) =
+            useDb {
+                new {
+                    this.eventID = event.id.value
+                    this.groupName = name
+                    this.groupType = type
+                }
             }
-        }
     }
 
     var eventID by EventGroupTable.event.transform({ EntityID(it, EventTable) }, { it.value })
@@ -97,7 +100,8 @@ class EventGroup(id: EntityID<Int>) : IntEntity(id) {
     val dependents by lazy { EventRelation.getGroupRelations(this) }
     val lastFight by lazy { Optional.ofNullable(fights.maxByOrNull { it.startTime }) }
 
-    fun getId() = id.value
+    fun getId() =
+        id.value
 
     private var points: Map<Team, Int>? = null
 
@@ -118,18 +122,22 @@ class EventGroup(id: EntityID<Int>) : IntEntity(id) {
                         blueTeamAdd += pointsPerWin
                         redTeamAdd += pointsPerLoss
                     }
+
                     2 -> {
                         blueTeamAdd += pointsPerLoss
                         redTeamAdd += pointsPerWin
                     }
+
                     0 -> if (fight.fight != null) {
                         blueTeamAdd += pointsPerDraw
                         redTeamAdd += pointsPerDraw
                     }
                 }
 
-                p[fight.teamBlue] = p[fight.teamBlue]?.plus(blueTeamAdd) ?: blueTeamAdd
-                p[fight.teamRed] = p[fight.teamRed]?.plus(redTeamAdd) ?: redTeamAdd
+                p[fight.teamBlue] = p[fight.teamBlue]?.plus(blueTeamAdd)
+                    ?: blueTeamAdd
+                p[fight.teamRed] = p[fight.teamRed]?.plus(redTeamAdd)
+                    ?: redTeamAdd
             }
 
             return p.mapKeys { Team.byId(it.key) }.also { points = it }
@@ -138,17 +146,20 @@ class EventGroup(id: EntityID<Int>) : IntEntity(id) {
         }
     }
 
-    fun needsTieBreak() = calculatePoints().values.let { it.size == it.toSet().size }
+    fun needsTieBreak() =
+        calculatePoints().values.let { it.size == it.toSet().size }
 
-    fun update(name: String, type: EventGroupType, pointsPerWin: Int, pointsPerLoss: Int, pointsPerDraw: Int) = useDb {
-        this@EventGroup.name = name
-        this@EventGroup.type = type
-        this@EventGroup.pointsPerWin = pointsPerWin
-        this@EventGroup.pointsPerLoss = pointsPerLoss
-        this@EventGroup.pointsPerDraw = pointsPerDraw
-    }
+    fun update(name: String, type: EventGroupType, pointsPerWin: Int, pointsPerLoss: Int, pointsPerDraw: Int) =
+        useDb {
+            this@EventGroup.name = name
+            this@EventGroup.type = type
+            this@EventGroup.pointsPerWin = pointsPerWin
+            this@EventGroup.pointsPerLoss = pointsPerLoss
+            this@EventGroup.pointsPerDraw = pointsPerDraw
+        }
 
-    override fun delete() = useDb { super.delete() }
+    override fun delete() =
+        useDb { super.delete() }
 
     enum class EventGroupType {
         GROUP_STAGE,

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

@@ -39,15 +39,17 @@ object EventRelationTable : IntIdTable("EventRelation") {
 class EventRelation(id: EntityID<Int>) : IntEntity(id) {
     companion object : IntEntityClass<EventRelation>(EventRelationTable) {
         @JvmStatic
-        fun get(event: Event) = useDb {
-            EventRelationTable.innerJoin(EventFightTable)
-                .select(EventRelationTable.columns)
-                .where { EventFightTable.eventId eq event.id }
-                .map { wrapRow(it) }
-        }
+        fun get(event: Event) =
+            useDb {
+                EventRelationTable.innerJoin(EventFightTable)
+                    .select(EventRelationTable.columns)
+                    .where { EventFightTable.eventId eq event.id }
+                    .map { wrapRow(it) }
+            }
 
         @JvmStatic
-        fun byId(id: Int) = useDb { findById(id) }
+        fun byId(id: Int) =
+            useDb { findById(id) }
 
         @JvmStatic
         fun getFightRelations(fight: EventFight) =
@@ -58,15 +60,16 @@ class EventRelation(id: EntityID<Int>) : IntEntity(id) {
             useDb { find { (EventRelationTable.fromId eq group.id.value) and (EventRelationTable.fromType eq FromType.GROUP) }.toList() }
 
         @JvmStatic
-        fun create(fight: EventFight, fightTeam: FightTeam, fromType: FromType, fromId: Int, fromPlace: Int) = useDb {
-            new {
-                this.fightEntityId = fight.id
-                this.fightTeam = fightTeam
-                this.fromType = fromType
-                this.fromId = fromId
-                this.fromPlace = fromPlace
+        fun create(fight: EventFight, fightTeam: FightTeam, fromType: FromType, fromId: Int, fromPlace: Int) =
+            useDb {
+                new {
+                    this.fightEntityId = fight.id
+                    this.fightTeam = fightTeam
+                    this.fromType = fromType
+                    this.fromId = fromId
+                    this.fromPlace = fromPlace
+                }
             }
-        }
     }
 
     var fightEntityId by EventRelationTable.fightId
@@ -100,33 +103,42 @@ class EventRelation(id: EntityID<Int>) : IntEntity(id) {
     var fromPlace by EventRelationTable.fromPlace
         private set
 
-    fun getId() = id.value
-    fun setUpdateTeam(team: FightTeam) = useDb {
-        fightTeam = team
-    }
+    fun getId() =
+        id.value
 
-    fun setFromFight(fight: EventFight, place: Int) = useDb {
-        fromType = FromType.FIGHT
-        fromId = fight.id.value
-        fromPlace = place
-    }
+    fun setUpdateTeam(team: FightTeam) =
+        useDb {
+            fightTeam = team
+        }
 
-    fun setFromGroup(group: EventGroup, place: Int) = useDb {
-        fromType = FromType.GROUP
-        fromId = group.id.value
-        fromPlace = place
-    }
+    fun setFromFight(fight: EventFight, place: Int) =
+        useDb {
+            fromType = FromType.FIGHT
+            fromId = fight.id.value
+            fromPlace = place
+        }
 
-    fun getAdvancingTeam(): Team? = useDb { when(fromType) {
-        FromType.FIGHT -> if (fromPlace == 0) fromFight?.winner else fromFight?.losser
-        FromType.GROUP -> fromGroup?.calculatePoints()?.toList()?.sortedBy { (_, v) -> v }?.reversed()?.elementAt(fromPlace)?.first
-    } }
+    fun setFromGroup(group: EventGroup, place: Int) =
+        useDb {
+            fromType = FromType.GROUP
+            fromId = group.id.value
+            fromPlace = place
+        }
+
+    fun getAdvancingTeam(): Team? =
+        useDb {
+            when (fromType) {
+                FromType.FIGHT -> if (fromPlace == 0) fromFight?.winner else fromFight?.losser
+                FromType.GROUP -> fromGroup?.calculatePoints()?.toList()?.sortedBy { (_, v) -> v }?.reversed()?.elementAt(fromPlace)?.first
+            }
+        }
 
     fun apply(): Boolean {
-        val team = getAdvancingTeam() ?: return false
+        val team = getAdvancingTeam()
+            ?: return false
 
         useDb {
-            when(fightTeam) {
+            when (fightTeam) {
                 FightTeam.BLUE -> fight.teamBlue = team.teamId
                 FightTeam.RED -> fight.teamRed = team.teamId
             }
@@ -135,9 +147,10 @@ class EventRelation(id: EntityID<Int>) : IntEntity(id) {
         return true
     }
 
-    override fun delete() = useDb {
-        super.delete()
-    }
+    override fun delete() =
+        useDb {
+            super.delete()
+        }
 
     enum class FightTeam {
         BLUE, RED

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

@@ -50,7 +50,8 @@ object FightTable : IntIdTable("Fight", "FightId") {
 class Fight(id: EntityID<Int>) : IntEntity(id) {
     companion object : IntEntityClass<Fight>(FightTable) {
         @JvmStatic
-        fun getById(id: Int) = useDb { get(id) }
+        fun getById(id: Int) =
+            useDb { get(id) }
 
         @JvmStatic
         fun create(
@@ -64,40 +65,43 @@ class Fight(id: EntityID<Int>) : IntEntity(id) {
             redschem: Int?,
             win: Int,
             wincondition: String
-        ): Int = useDb {
-            FightTable.insertAndGetId {
-                it[FightTable.gamemode] = gamemode
-                it[FightTable.server] = server
-                it[FightTable.startTime] = starttime.toInstant()
-                it[FightTable.duration] = duration
-                it[FightTable.blueLeader] = EntityID(blueleader, SteamwarUserTable)
-                it[FightTable.redLeader] = EntityID(redleader, SteamwarUserTable)
-                it[FightTable.blueSchem] = blueschem?.let { EntityID(it, SchematicNodeTable) }
-                it[FightTable.redSchem] = redschem?.let { EntityID(it, SchematicNodeTable) }
-                it[FightTable.win] = WinningTeam.entries[win]
-                it[FightTable.winCondition] = wincondition
-            }.value
-        }
-
-        @JvmStatic
-        fun getPage(page: Int, pageSize: Int): List<Fight> = useDb {
-            val fights = all().orderBy(FightTable.startTime to SortOrder.DESC).limit(pageSize).offset((pageSize * page).toLong())
-
-            val fightPlayer = FightPlayer.batchGet(fights.map { it.id.value })
-            for (fight in fights) {
-                fight.initPlayers(fightPlayer)
+        ): Int =
+            useDb {
+                FightTable.insertAndGetId {
+                    it[FightTable.gamemode] = gamemode
+                    it[FightTable.server] = server
+                    it[FightTable.startTime] = starttime.toInstant()
+                    it[FightTable.duration] = duration
+                    it[FightTable.blueLeader] = EntityID(blueleader, SteamwarUserTable)
+                    it[FightTable.redLeader] = EntityID(redleader, SteamwarUserTable)
+                    it[FightTable.blueSchem] = blueschem?.let { EntityID(it, SchematicNodeTable) }
+                    it[FightTable.redSchem] = redschem?.let { EntityID(it, SchematicNodeTable) }
+                    it[FightTable.win] = WinningTeam.entries[win]
+                    it[FightTable.winCondition] = wincondition
+                }.value
             }
 
-            SteamwarUser.batchCache(fightPlayer.map { it.userID }.toMutableSet())
-            fights.toList()
-        }
+        @JvmStatic
+        fun getPage(page: Int, pageSize: Int): List<Fight> =
+            useDb {
+                val fights = all().orderBy(FightTable.startTime to SortOrder.DESC).limit(pageSize).offset((pageSize * page).toLong())
+
+                val fightPlayer = FightPlayer.batchGet(fights.map { it.id.value })
+                for (fight in fights) {
+                    fight.initPlayers(fightPlayer)
+                }
+
+                SteamwarUser.batchCache(fightPlayer.map { it.userID }.toMutableSet())
+                fights.toList()
+            }
 
         @JvmStatic
-        fun markReplayAvailable(id: Int) = useDb {
-            FightTable.update({ FightTable.id eq id }) {
-                it[replayAvailable] = true
+        fun markReplayAvailable(id: Int) =
+            useDb {
+                FightTable.update({ FightTable.id eq id }) {
+                    it[replayAvailable] = true
+                }
             }
-        }
     }
 
     val fightID by FightTable.id.transform({ EntityID(it, FightTable) }, { it.value })
@@ -131,12 +135,16 @@ class Fight(id: EntityID<Int>) : IntEntity(id) {
                 } else {
                     false
                 }
-            } ?: false
+            }
+                ?: false
         }
     }
 
-    fun replayExists() = schemType != null && replayAvailable
-    fun replayAllowed() = replayAllowed
+    fun replayExists() =
+        schemType != null && replayAvailable
+
+    fun replayAllowed() =
+        replayAllowed
 
     lateinit var bluePlayers: List<FightPlayer>
     lateinit var redPlayers: List<FightPlayer>
@@ -146,10 +154,11 @@ class Fight(id: EntityID<Int>) : IntEntity(id) {
         val red = mutableListOf<FightPlayer>()
 
         for (player in fightPlayers.filter { it.fightID == id.value }) {
-            if (player.team == 1)
+            if (player.team == 1) {
                 blue.add(player)
-            else
+            } else {
                 red.add(player)
+            }
         }
 
         bluePlayers = blue

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

@@ -52,21 +52,23 @@ class FightPlayer(id: EntityID<CompositeID>) : CompositeEntity(id) {
             kit: String,
             kills: Int,
             out: Boolean
-        ) = useDb {
-            FightPlayerTable.insertIgnore {
-                it[this.fightId] = fightId
-                it[this.userId] = userId
-                it[this.team] = if (blue) 1 else 2
-                it[this.kit] = kit
-                it[this.kills] = kills
-                it[this.out] = out
+        ) =
+            useDb {
+                FightPlayerTable.insertIgnore {
+                    it[this.fightId] = fightId
+                    it[this.userId] = userId
+                    it[this.team] = if (blue) 1 else 2
+                    it[this.kit] = kit
+                    it[this.kills] = kills
+                    it[this.out] = out
+                }
             }
-        }
 
         @JvmStatic
-        fun batchGet(fightIds: List<Int>) = useDb {
-            find { FightPlayerTable.fightId inList fightIds.toList() }.toList()
-        }
+        fun batchGet(fightIds: List<Int>) =
+            useDb {
+                find { FightPlayerTable.fightId inList fightIds.toList() }.toList()
+            }
     }
 
     val fightID by FightPlayerTable.fightId.transform({ EntityID(it, FightTable) }, { it.value })
@@ -76,5 +78,6 @@ class FightPlayer(id: EntityID<CompositeID>) : CompositeEntity(id) {
     val kills by FightPlayerTable.kills
     val out by FightPlayerTable.out
 
-    fun isOut() = out
+    fun isOut() =
+        out
 }

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

@@ -984,8 +984,7 @@ public final class GameModeConfig<M, W> {
 
     public String hasMap(String map) {
         for (String m : Server.Maps) {
-            if (m.equalsIgnoreCase(map))
-                return m;
+            if (m.equalsIgnoreCase(map)) return m;
         }
         return null;
     }

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

@@ -29,7 +29,7 @@ import org.jetbrains.exposed.v1.dao.CompositeEntity
 import org.jetbrains.exposed.v1.dao.CompositeEntityClass
 import java.util.*
 
-object IgnoreSystemTable: CompositeIdTable("IgnoredPlayers") {
+object IgnoreSystemTable : CompositeIdTable("IgnoredPlayers") {
     val ignorer = reference("Ignorer", SteamwarUserTable).index()
     val ignored = reference("Ignored", SteamwarUserTable).index()
 
@@ -47,28 +47,32 @@ class IgnoreSystem(id: EntityID<CompositeID>) : CompositeEntity(id) {
 
     companion object : CompositeEntityClass<IgnoreSystem>(IgnoreSystemTable) {
         @JvmStatic
-        fun isIgnored(ignorer: UUID, ignored: UUID) = useDb { isIgnored(SteamwarUser.get(ignorer)!!, SteamwarUser.get(ignored)!!) }
+        fun isIgnored(ignorer: UUID, ignored: UUID) =
+            useDb { isIgnored(SteamwarUser.get(ignorer)!!, SteamwarUser.get(ignored)!!) }
 
         @JvmStatic
-        fun isIgnored(ignorer: SteamwarUser, ignored: SteamwarUser) = useDb {
-            find {
-                (IgnoreSystemTable.ignorer eq ignorer.id) and (IgnoreSystemTable.ignored eq ignored.id)
-            }.firstOrNull() != null
-        }
-
-        @JvmStatic
-        fun ignore(ignorer: SteamwarUser, ignored: SteamwarUser) = useDb {
-            new {
-                this.ignorer = ignorer.id
-                this.ignored = ignored.id
+        fun isIgnored(ignorer: SteamwarUser, ignored: SteamwarUser) =
+            useDb {
+                find {
+                    (IgnoreSystemTable.ignorer eq ignorer.id) and (IgnoreSystemTable.ignored eq ignored.id)
+                }.firstOrNull() != null
             }
-        }
 
         @JvmStatic
-        fun unIgnore(ignorer: SteamwarUser, ignored: SteamwarUser) = useDb {
-            find {
-                (IgnoreSystemTable.ignorer eq ignorer.id) and (IgnoreSystemTable.ignored eq ignored.id)
-            }.firstOrNull()?.delete()
-        }
+        fun ignore(ignorer: SteamwarUser, ignored: SteamwarUser) =
+            useDb {
+                new {
+                    this.ignorer = ignorer.id
+                    this.ignored = ignored.id
+                }
+            }
+
+        @JvmStatic
+        fun unIgnore(ignorer: SteamwarUser, ignored: SteamwarUser) =
+            useDb {
+                find {
+                    (IgnoreSystemTable.ignorer eq ignorer.id) and (IgnoreSystemTable.ignored eq ignored.id)
+                }.firstOrNull()?.delete()
+            }
     }
 }

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

@@ -48,37 +48,42 @@ object LeaderboardTable : CompositeIdTable("Leaderboard") {
 class Leaderboard(id: EntityID<CompositeID>) : CompositeEntity(id) {
     companion object : CompositeEntityClass<Leaderboard>(LeaderboardTable) {
         @JvmStatic
-        fun getLeaderboard(name: String) = useDb {
-            find { LeaderboardTable.name eq name }.orderBy(LeaderboardTable.time to SortOrder.ASC).limit(5).toList()
-        }
-
-        @JvmStatic
-        fun getPlayerTime(user: SteamwarUser, name: String) = useDb {
-            find { (LeaderboardTable.userId eq user.id.value) and (LeaderboardTable.name eq name) }.firstOrNull()
-        }
-
-        @JvmStatic
-        fun getPlayerPlacement(user: SteamwarUser, name: String) = useDb {
-            LeaderboardTable.select(LeaderboardTable.time.count())
-                .where {
-                    (LeaderboardTable.name eq name) and (LeaderboardTable.time lessSubQuery LeaderboardTable.select(
-                        LeaderboardTable.time
-                    ).where { (LeaderboardTable.userId eq user.id.value) and (LeaderboardTable.name eq name) })
-                }
-                .firstOrNull()?.get(LeaderboardTable.time.count())?.toInt() ?: Int.MAX_VALUE
-        }
-
-        @JvmStatic
-        fun upsert(userId: Int, name: String, time: Long, bestTime: Boolean) = useDb {
-            LeaderboardTable.upsert(
-                onUpdateExclude = listOf(LeaderboardTable.updatedAt, LeaderboardTable.userId, LeaderboardTable.name)
-            ) {
-                it[LeaderboardTable.userId] = userId
-                it[LeaderboardTable.name] = name
-                it[LeaderboardTable.time] = time
-                it[LeaderboardTable.bestTime] = bestTime
+        fun getLeaderboard(name: String) =
+            useDb {
+                find { LeaderboardTable.name eq name }.orderBy(LeaderboardTable.time to SortOrder.ASC).limit(5).toList()
+            }
+
+        @JvmStatic
+        fun getPlayerTime(user: SteamwarUser, name: String) =
+            useDb {
+                find { (LeaderboardTable.userId eq user.id.value) and (LeaderboardTable.name eq name) }.firstOrNull()
+            }
+
+        @JvmStatic
+        fun getPlayerPlacement(user: SteamwarUser, name: String) =
+            useDb {
+                LeaderboardTable.select(LeaderboardTable.time.count())
+                    .where {
+                        (LeaderboardTable.name eq name) and (LeaderboardTable.time lessSubQuery LeaderboardTable.select(
+                            LeaderboardTable.time
+                        ).where { (LeaderboardTable.userId eq user.id.value) and (LeaderboardTable.name eq name) })
+                    }
+                    .firstOrNull()?.get(LeaderboardTable.time.count())?.toInt()
+                    ?: Int.MAX_VALUE
+            }
+
+        @JvmStatic
+        fun upsert(userId: Int, name: String, time: Long, bestTime: Boolean) =
+            useDb {
+                LeaderboardTable.upsert(
+                    onUpdateExclude = listOf(LeaderboardTable.updatedAt, LeaderboardTable.userId, LeaderboardTable.name)
+                ) {
+                    it[LeaderboardTable.userId] = userId
+                    it[LeaderboardTable.name] = name
+                    it[LeaderboardTable.time] = time
+                    it[LeaderboardTable.bestTime] = bestTime
+                }
             }
-        }
     }
 
     val user by LeaderboardTable.userId.transform({ EntityID(it, SteamwarUserTable) }, { it.value })

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

@@ -38,31 +38,36 @@ object ModTable : CompositeIdTable("Mods") {
 class Mod(id: EntityID<CompositeID>) : CompositeEntity(id) {
     companion object : CompositeEntityClass<Mod>(ModTable) {
         @JvmStatic
-        fun get(modName: String, platform: Platform) = useDb {
-            find { ModTable.platform eq platform and (ModTable.modName eq modName) }.firstOrNull()
-        }
-
-        @JvmStatic
-        fun getOrCreate(modName: String, platform: Platform) = useDb {
-            get(modName, platform) ?: new {
-                this.platform = platform
-                this.modName = modName
-                this.type = ModType.UNKLASSIFIED
+        fun get(modName: String, platform: Platform) =
+            useDb {
+                find { ModTable.platform eq platform and (ModTable.modName eq modName) }.firstOrNull()
             }
-        }
 
         @JvmStatic
-        fun getAllModsFiltered(page: Int, elementsPerPage: Int, filter: ModType) = useDb {
-            find { ModTable.modeType eq filter }.limit(elementsPerPage).offset((elementsPerPage * page).toLong())
-                .orderBy(
-                    ModTable.modName to SortOrder.DESC
-                ).toList()
-        }
+        fun getOrCreate(modName: String, platform: Platform) =
+            useDb {
+                get(modName, platform)
+                    ?: new {
+                        this.platform = platform
+                        this.modName = modName
+                        this.type = ModType.UNKLASSIFIED
+                    }
+            }
 
         @JvmStatic
-        fun findFirstMod() = useDb {
-            find { ModTable.modeType eq ModType.UNKLASSIFIED }.limit(1).firstOrNull()
-        }
+        fun getAllModsFiltered(page: Int, elementsPerPage: Int, filter: ModType) =
+            useDb {
+                find { ModTable.modeType eq filter }.limit(elementsPerPage).offset((elementsPerPage * page).toLong())
+                    .orderBy(
+                        ModTable.modName to SortOrder.DESC
+                    ).toList()
+            }
+
+        @JvmStatic
+        fun findFirstMod() =
+            useDb {
+                find { ModTable.modeType eq ModType.UNKLASSIFIED }.limit(1).firstOrNull()
+            }
     }
 
     var platform by ModTable.platform

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

@@ -34,7 +34,7 @@ import org.jetbrains.exposed.v1.jdbc.insert
 import java.io.InputStream
 import java.util.zip.GZIPInputStream
 
-object NodeDataTable: CompositeIdTable("NodeData") {
+object NodeDataTable : CompositeIdTable("NodeData") {
     val nodeId = reference("NodeId", SchematicNodeTable).index()
     val createdAt = timestamp("CreatedAt").defaultExpression(CurrentTimestamp).entityId()
     val nodeFormat = enumeration("NodeFormat", NodeData.SchematicFormat::class)
@@ -47,48 +47,55 @@ object NodeDataTable: CompositeIdTable("NodeData") {
     }
 }
 
-class NodeData(id: EntityID<CompositeID>): CompositeEntity(id) {
+class NodeData(id: EntityID<CompositeID>) : CompositeEntity(id) {
     val nodeId by NodeDataTable.nodeId
     val createdAt by NodeDataTable.createdAt
     val nodeFormat by NodeDataTable.nodeFormat
     val schemData by NodeDataTable.schemData
 
-    companion object: CompositeEntityClass<NodeData>(NodeDataTable) {
+    companion object : CompositeEntityClass<NodeData>(NodeDataTable) {
         @JvmStatic
-        fun getLatest(node: SchematicNode) = useDb {
-            find { (NodeDataTable.nodeId eq node.nodeId) }.orderBy(NodeDataTable.createdAt to SortOrder.DESC).firstOrNull()
-        }
-
-        @JvmStatic
-        fun get(node: SchematicNode) = useDb {
-            find { (NodeDataTable.nodeId eq node.nodeId) }.orderBy(NodeDataTable.createdAt to SortOrder.ASC).toList()
-        }
-
-        @JvmStatic
-        fun get(node: SchematicNode, revision: Int) = useDb {
-            find { NodeDataTable.nodeId eq node.nodeId }.orderBy(NodeDataTable.createdAt to SortOrder.ASC).toList().get(revision - 1)
-        }
-
-        @JvmStatic
-        fun getRevisions(node: SchematicNode) = useDb {
-            count(NodeDataTable.nodeId eq node.nodeId).toInt()
-        }
-
-        @JvmStatic
-        fun saveFromStream(node: SchematicNode, blob: InputStream, format: SchematicFormat) = useDb {
-            NodeDataTable.insert {
-                it[NodeDataTable.nodeId] = EntityID(node.getId(), SchematicNodeTable)
-                it[NodeDataTable.nodeFormat] = format
-                it[NodeDataTable.schemData] = ExposedBlob(blob.readBytes())
+        fun getLatest(node: SchematicNode) =
+            useDb {
+                find { (NodeDataTable.nodeId eq node.nodeId) }.orderBy(NodeDataTable.createdAt to SortOrder.DESC).firstOrNull()
             }
+
+        @JvmStatic
+        fun get(node: SchematicNode) =
+            useDb {
+                find { (NodeDataTable.nodeId eq node.nodeId) }.orderBy(NodeDataTable.createdAt to SortOrder.ASC).toList()
+            }
+
+        @JvmStatic
+        fun get(node: SchematicNode, revision: Int) =
+            useDb {
+                find { NodeDataTable.nodeId eq node.nodeId }.orderBy(NodeDataTable.createdAt to SortOrder.ASC).toList().get(revision - 1)
+            }
+
+        @JvmStatic
+        fun getRevisions(node: SchematicNode) =
+            useDb {
+                count(NodeDataTable.nodeId eq node.nodeId).toInt()
+            }
+
+        @JvmStatic
+        fun saveFromStream(node: SchematicNode, blob: InputStream, format: SchematicFormat) =
+            useDb {
+                NodeDataTable.insert {
+                    it[NodeDataTable.nodeId] = EntityID(node.getId(), SchematicNodeTable)
+                    it[NodeDataTable.nodeFormat] = format
+                    it[NodeDataTable.schemData] = ExposedBlob(blob.readBytes())
+                }
+            }
+    }
+
+    fun schemData(decompress: Boolean) =
+        useDb {
+            schemData.inputStream.let { if (decompress) GZIPInputStream(it) else it }
         }
-    }
 
-    fun schemData(decompress: Boolean) = useDb {
-        schemData.inputStream.let { if(decompress) GZIPInputStream(it) else it }
-    }
-
-    override fun delete() = useDb { super.delete() }
+    override fun delete() =
+        useDb { super.delete() }
 
     enum class SchematicFormat(val fileEnding: String) {
         MCEDIT(".schematic"),

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

@@ -32,7 +32,7 @@ import java.security.MessageDigest
 import java.sql.Timestamp
 import java.time.Instant
 
-object NodeDownloadTable: IdTable<Int>("NodeDownload") {
+object NodeDownloadTable : IdTable<Int>("NodeDownload") {
     override val id = reference("NodeId", SchematicNodeTable, onDelete = ReferenceOption.CASCADE).uniqueIndex()
     val link = varchar("Link", 255).uniqueIndex()
     val timestamp = timestamp("Timestamp").defaultExpression(CurrentTimestamp)
@@ -44,8 +44,7 @@ class NodeDownload(id: EntityID<Int>) : IntEntity(id) {
 
         @JvmStatic
         fun getLink(schem: SchematicNode): String {
-            if (schem.isDir())
-                throw IllegalArgumentException("Cannot get link for directory")
+            if (schem.isDir()) throw IllegalArgumentException("Cannot get link for directory")
 
             val digest = MessageDigest.getInstance("SHA-1")
             digest.update("${Instant.now()}${schem.owner}${schem.nodeId}".toByteArray())
@@ -53,25 +52,28 @@ class NodeDownload(id: EntityID<Int>) : IntEntity(id) {
             useDb {
                 findByIdAndUpdate(schem.id.value) {
                     it.link = hash
-                } ?: new {
-                    nodeId = schem.id.value
-                    link = hash
                 }
+                    ?: new {
+                        nodeId = schem.id.value
+                        link = hash
+                    }
             }
             return "${LINK_BASE}${hash}"
         }
 
         @JvmStatic
-        fun get(link: String) = useDb {
-            find { NodeDownloadTable.link eq link }.firstOrNull()
-        }
+        fun get(link: String) =
+            useDb {
+                find { NodeDownloadTable.link eq link }.firstOrNull()
+            }
     }
 
     var nodeId by NodeDownloadTable.id.transform({ EntityID(it, SchematicNodeTable) }, { it.value })
     var link by NodeDownloadTable.link
     var timestamp by NodeDownloadTable.timestamp.transform({ it.toInstant() }, { Timestamp.from(it) })
 
-    override fun delete() = useDb {
-        super.delete()
-    }
+    override fun delete() =
+        useDb {
+            super.delete()
+        }
 }

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

@@ -48,44 +48,54 @@ object NodeMemberTable : CompositeIdTable("NodeMember") {
 class NodeMember(id: EntityID<CompositeID>) : CompositeEntity(id) {
     companion object : CompositeEntityClass<NodeMember>(NodeMemberTable) {
         @JvmStatic
-        fun createNodeMember(node: Int, member: Int): NodeMember = useDb {
-            NodeMemberTable.insertIgnore {
-                it[this.node] = EntityID(node, SchematicNodeTable)
-                it[this.userId] = EntityID(member, SteamwarUserTable)
+        fun createNodeMember(node: Int, member: Int): NodeMember =
+            useDb {
+                NodeMemberTable.insertIgnore {
+                    it[this.node] = EntityID(node, SchematicNodeTable)
+                    it[this.userId] = EntityID(member, SteamwarUserTable)
+                }
+                getNodeMember(node, member)
+                    ?: throw IllegalStateException("NodeMember not created")
             }
-            getNodeMember(node, member) ?: throw IllegalStateException("NodeMember not created")
-        }
 
         @JvmStatic
-        fun createNodeMember(node: Int, member: Int, parent: SchematicNode): NodeMember = useDb {
-            if (!parent.isDir()) throw IllegalStateException("Parent must be a directory")
-            NodeMemberTable.insertIgnore {
-                it[this.node] = EntityID(node, SchematicNodeTable)
-                it[this.userId] = EntityID(member, SteamwarUserTable)
-                it[NodeMemberTable.parentNode] = parent.getId()
+        fun createNodeMember(node: Int, member: Int, parent: SchematicNode): NodeMember =
+            useDb {
+                if (!parent.isDir()) throw IllegalStateException("Parent must be a directory")
+                NodeMemberTable.insertIgnore {
+                    it[this.node] = EntityID(node, SchematicNodeTable)
+                    it[this.userId] = EntityID(member, SteamwarUserTable)
+                    it[NodeMemberTable.parentNode] = parent.getId()
+                }
+                getNodeMember(node, member)
+                    ?: throw IllegalStateException("NodeMember not created")
             }
-            getNodeMember(node, member) ?: throw IllegalStateException("NodeMember not created")
-        }
 
         @JvmStatic
-        fun createNodeMember(node: Int, member: SteamwarUser) = createNodeMember(node, member.id.value)
+        fun createNodeMember(node: Int, member: SteamwarUser) =
+            createNodeMember(node, member.id.value)
 
         @JvmStatic
-        fun getNodeMember(node: Int, member: Int) = useDb {
-            find { (NodeMemberTable.node eq node) and (NodeMemberTable.userId eq member) }.firstOrNull()
-        }
+        fun getNodeMember(node: Int, member: Int) =
+            useDb {
+                find { (NodeMemberTable.node eq node) and (NodeMemberTable.userId eq member) }.firstOrNull()
+            }
 
         @JvmStatic
-        fun getNodeMember(node: Int, member: SteamwarUser) = getNodeMember(node, member.id.value)
+        fun getNodeMember(node: Int, member: SteamwarUser) =
+            getNodeMember(node, member.id.value)
 
         @JvmStatic
-        fun getNodeMembers(node: Int) = useDb { find { NodeMemberTable.node eq node }.toSet() }
+        fun getNodeMembers(node: Int) =
+            useDb { find { NodeMemberTable.node eq node }.toSet() }
 
         @JvmStatic
-        fun getSchematics(member: Int) = useDb { find { NodeMemberTable.userId eq member }.toSet() }
+        fun getSchematics(member: Int) =
+            useDb { find { NodeMemberTable.userId eq member }.toSet() }
 
         @JvmStatic
-        fun init() = Unit
+        fun init() =
+            Unit
     }
 
     val node by NodeMemberTable.node.transform({ EntityID(it, SchematicNodeTable) }, { it.value })
@@ -95,11 +105,13 @@ class NodeMember(id: EntityID<CompositeID>) : CompositeEntity(id) {
         { Optional.ofNullable(it?.value) })
         private set
 
-    fun setParentId(id: Int?) = useDb {
-        parent = Optional.ofNullable(id)
-    }
+    fun setParentId(id: Int?) =
+        useDb {
+            parent = Optional.ofNullable(id)
+        }
 
-    override fun delete() = useDb {
-        super.delete()
-    }
+    override fun delete() =
+        useDb {
+            super.delete()
+        }
 }

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

@@ -28,7 +28,7 @@ import org.jetbrains.exposed.v1.core.eq
 import org.jetbrains.exposed.v1.dao.CompositeEntity
 import org.jetbrains.exposed.v1.dao.CompositeEntityClass
 
-object PersonalKitTable: CompositeIdTable("PersonalKit") {
+object PersonalKitTable : CompositeIdTable("PersonalKit") {
     val userId = reference("UserId", SteamwarUserTable)
     val gamemode = varchar("Gamemode", 64).entityId()
     val kitName = varchar("Name", 64).entityId()
@@ -44,43 +44,47 @@ object PersonalKitTable: CompositeIdTable("PersonalKit") {
     }
 }
 
-class InternalKit(id: EntityID<CompositeID>): CompositeEntity(id) {
-    companion object: CompositeEntityClass<InternalKit>(PersonalKitTable) {
+class InternalKit(id: EntityID<CompositeID>) : CompositeEntity(id) {
+    companion object : CompositeEntityClass<InternalKit>(PersonalKitTable) {
         @JvmStatic
-        fun get(userId: Int, gamemode: String) = useDb {
-            find { PersonalKitTable.userId eq userId and (PersonalKitTable.gamemode eq gamemode) }
-                .toList()
-        }
+        fun get(userId: Int, gamemode: String) =
+            useDb {
+                find { PersonalKitTable.userId eq userId and (PersonalKitTable.gamemode eq gamemode) }
+                    .toList()
+            }
 
         @JvmStatic
-        fun get(userId: Int, gamemode: String, kitName: String) = useDb {
-            findById(CompositeID {
-                it[PersonalKitTable.userId] = EntityID(userId, SteamwarUserTable)
-                it[PersonalKitTable.gamemode] = gamemode
-                it[PersonalKitTable.kitName] = kitName
-            })
-        }
-
-        @JvmStatic
-        fun create(userId: Int, gamemode: String, kitName: String, rawInventory: String, rawArmor: String) = useDb {
-            new(
-                CompositeID {
+        fun get(userId: Int, gamemode: String, kitName: String) =
+            useDb {
+                findById(CompositeID {
                     it[PersonalKitTable.userId] = EntityID(userId, SteamwarUserTable)
                     it[PersonalKitTable.gamemode] = gamemode
                     it[PersonalKitTable.kitName] = kitName
-                }
-            ) {
-                this.rawInventory = rawInventory
-                this.rawArmor = rawArmor
-                this.inUse = false
-            }.also { it.setDefault() }
-        }
+                })
+            }
 
         @JvmStatic
-        fun getKitInUse(userId: Int, gamemode: String) = useDb {
-            find { PersonalKitTable.userId eq userId and (PersonalKitTable.gamemode eq gamemode) and (PersonalKitTable.inUse eq true) }
-                .firstOrNull()
-        }
+        fun create(userId: Int, gamemode: String, kitName: String, rawInventory: String, rawArmor: String) =
+            useDb {
+                new(
+                    CompositeID {
+                        it[PersonalKitTable.userId] = EntityID(userId, SteamwarUserTable)
+                        it[PersonalKitTable.gamemode] = gamemode
+                        it[PersonalKitTable.kitName] = kitName
+                    }
+                ) {
+                    this.rawInventory = rawInventory
+                    this.rawArmor = rawArmor
+                    this.inUse = false
+                }.also { it.setDefault() }
+            }
+
+        @JvmStatic
+        fun getKitInUse(userId: Int, gamemode: String) =
+            useDb {
+                find { PersonalKitTable.userId eq userId and (PersonalKitTable.gamemode eq gamemode) and (PersonalKitTable.inUse eq true) }
+                    .firstOrNull()
+            }
     }
 
     var userID by PersonalKitTable.userId.transform({ EntityID(it, SteamwarUserTable) }, { it.value })
@@ -108,14 +112,16 @@ class InternalKit(id: EntityID<CompositeID>): CompositeEntity(id) {
         get() = rawArmor
         set(value) = useDb { rawArmor = value }
 
-    fun setDefault() = useDb {
-        find { PersonalKitTable.userId eq userID and (PersonalKitTable.gamemode eq gameMode) and (PersonalKitTable.inUse eq true) }
-            .filter { it.id.value != this@InternalKit.id.value }
-            .forEach { it.inUse = false }
-        inUse = true
-    }
+    fun setDefault() =
+        useDb {
+            find { PersonalKitTable.userId eq userID and (PersonalKitTable.gamemode eq gameMode) and (PersonalKitTable.inUse eq true) }
+                .filter { it.id.value != this@InternalKit.id.value }
+                .forEach { it.inUse = false }
+            inUse = true
+        }
 
-    override fun delete() = useDb {
-        super.delete()
-    }
+    override fun delete() =
+        useDb {
+            super.delete()
+        }
 }

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

@@ -52,37 +52,42 @@ class Punishment(id: EntityID<Int>) : IntEntity(id) {
         val PERMA_TIME: Timestamp = Timestamp.from(Instant.ofEpochSecond(946674800))
 
         @JvmStatic
-        fun getPunsihmentOfPlayer(user: Int, type: PunishmentType) = useDb {
-            find { (PunishmentTable.userId eq user) and (PunishmentTable.type eq type) }.orderBy(PunishmentTable.id to SortOrder.DESC)
-                .firstOrNull()
-        }
-
-        @JvmStatic
-        fun getPunishmentsOfPlayer(user: Int) = useDb {
-            find {
-                PunishmentTable.id inSubQuery PunishmentTable.select(PunishmentTable.id.max())
-                    .where { PunishmentTable.userId eq user }.groupBy(
-                        PunishmentTable.type
-                    )
-            }.associateBy { it.type }.toMutableMap()
-        }
-
-        @JvmStatic
-        fun getAllPunishmentsOfPlayer(user: Int) = useDb {
-            find { PunishmentTable.userId eq user }.orderBy(PunishmentTable.id to SortOrder.DESC).toList()
-        }
-
-        @JvmStatic
-        fun isPunished(user: SteamwarUser, type: PunishmentType, callback: Consumer<Punishment>): Boolean = useDb {
-            val punishment = getPunsihmentOfPlayer(user.id.value, type) ?: return@useDb false
-
-            if (punishment.isCurrent()) {
-                callback.accept(punishment)
-                return@useDb true
+        fun getPunsihmentOfPlayer(user: Int, type: PunishmentType) =
+            useDb {
+                find { (PunishmentTable.userId eq user) and (PunishmentTable.type eq type) }.orderBy(PunishmentTable.id to SortOrder.DESC)
+                    .firstOrNull()
             }
 
-            return@useDb false
-        }
+        @JvmStatic
+        fun getPunishmentsOfPlayer(user: Int) =
+            useDb {
+                find {
+                    PunishmentTable.id inSubQuery PunishmentTable.select(PunishmentTable.id.max())
+                        .where { PunishmentTable.userId eq user }.groupBy(
+                            PunishmentTable.type
+                        )
+                }.associateBy { it.type }.toMutableMap()
+            }
+
+        @JvmStatic
+        fun getAllPunishmentsOfPlayer(user: Int) =
+            useDb {
+                find { PunishmentTable.userId eq user }.orderBy(PunishmentTable.id to SortOrder.DESC).toList()
+            }
+
+        @JvmStatic
+        fun isPunished(user: SteamwarUser, type: PunishmentType, callback: Consumer<Punishment>): Boolean =
+            useDb {
+                val punishment = getPunsihmentOfPlayer(user.id.value, type)
+                    ?: return@useDb false
+
+                if (punishment.isCurrent()) {
+                    callback.accept(punishment)
+                    return@useDb true
+                }
+
+                return@useDb false
+            }
 
         @JvmStatic
         fun createPunishment(
@@ -92,17 +97,18 @@ class Punishment(id: EntityID<Int>) : IntEntity(id) {
             reason: String,
             endTime: Timestamp,
             perma: Boolean
-        ) = useDb {
-            new {
-                this.userId = user
-                this.punisher = executor
-                this.type = type
-                this.startTime = Timestamp.from(Instant.now())
-                this.endTime = endTime
-                this.perma = perma
-                this.reason = reason
+        ) =
+            useDb {
+                new {
+                    this.userId = user
+                    this.punisher = executor
+                    this.type = type
+                    this.startTime = Timestamp.from(Instant.now())
+                    this.endTime = endTime
+                    this.perma = perma
+                    this.reason = reason
+                }
             }
-        }
     }
 
     var userId by PunishmentTable.userId.transform({ EntityID(it, SteamwarUserTable) }, { it.value })
@@ -120,9 +126,11 @@ class Punishment(id: EntityID<Int>) : IntEntity(id) {
     var reason by PunishmentTable.reason
         private set
 
-    fun isPerma() = perma
+    fun isPerma() =
+        perma
 
-    fun isCurrent() = perma || endTime.after(Date())
+    fun isCurrent() =
+        perma || endTime.after(Date())
 
     enum class PunishmentType(
         val teamMessage: String?,
@@ -185,6 +193,7 @@ class Punishment(id: EntityID<Int>) : IntEntity(id) {
         ),
         Note("NOTE_TEAM", null, null, null, null, UserPerm.PUNISHMENTS, true);
 
-        fun isMulti() = multi
+        fun isMulti() =
+            multi
     }
 }

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

@@ -28,7 +28,7 @@ import org.jetbrains.exposed.v1.core.eq
 import org.jetbrains.exposed.v1.dao.CompositeEntity
 import org.jetbrains.exposed.v1.dao.CompositeEntityClass
 
-object RefereeTable: CompositeIdTable("Referee") {
+object RefereeTable : CompositeIdTable("Referee") {
     val eventId = reference("EventId", EventTable)
     val userId = reference("UserId", SteamwarUserTable).index()
 
@@ -40,25 +40,28 @@ object RefereeTable: CompositeIdTable("Referee") {
     }
 }
 
-class Referee(id: EntityID<CompositeID>): CompositeEntity(id) {
-    companion object: CompositeEntityClass<Referee>(RefereeTable) {
+class Referee(id: EntityID<CompositeID>) : CompositeEntity(id) {
+    companion object : CompositeEntityClass<Referee>(RefereeTable) {
         @JvmStatic
-        fun add(eventId: Int, userId: Int) = useDb {
-            new {
-                this.eventID = eventId
-                this.userID = userId
+        fun add(eventId: Int, userId: Int) =
+            useDb {
+                new {
+                    this.eventID = eventId
+                    this.userID = userId
+                }
             }
-        }
 
         @JvmStatic
-        fun remove(eventId: Int, userId: Int) = useDb {
-            find { (RefereeTable.eventId eq eventId) and (RefereeTable.userId eq userId) }.firstOrNull()?.delete()
-        }
+        fun remove(eventId: Int, userId: Int) =
+            useDb {
+                find { (RefereeTable.eventId eq eventId) and (RefereeTable.userId eq userId) }.firstOrNull()?.delete()
+            }
 
         @JvmStatic
-        fun get(event: Int) = useDb {
-            find { RefereeTable.eventId eq event }.map { it.userID }.toSet()
-        }
+        fun get(event: Int) =
+            useDb {
+                find { RefereeTable.eventId eq event }.map { it.userID }.toSet()
+            }
     }
 
     var eventID by RefereeTable.eventId.transform({ EntityID(it, EventTable) }, { it.value })

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

@@ -27,7 +27,7 @@ import org.jetbrains.exposed.v1.jdbc.insert
 import org.jetbrains.exposed.v1.jdbc.insertAndGetId
 import java.io.File
 
-object ExceptionTable: IntIdTable("Exception") {
+object ExceptionTable : IntIdTable("Exception") {
     val time = timestamp("Time").defaultExpression(CurrentTimestamp)
     val server = text("Server")
     val message = text("Message")
@@ -40,27 +40,30 @@ class SWException {
         val serverName = File(cwd).name
 
         @JvmStatic
-        fun init() = Unit
+        fun init() =
+            Unit
 
         @JvmStatic
-        fun log(message: String, stacktrace: String) = useDb {
-            ExceptionTable.insert {
-                it[ExceptionTable.server] = serverName
-                it[ExceptionTable.message] = generateMessage(message)
-                it[ExceptionTable.stackTrace] = stacktrace
+        fun log(message: String, stacktrace: String) =
+            useDb {
+                ExceptionTable.insert {
+                    it[ExceptionTable.server] = serverName
+                    it[ExceptionTable.message] = generateMessage(message)
+                    it[ExceptionTable.stackTrace] = stacktrace
+                }
+
+                Unit
             }
 
-            Unit
-        }
-
         @JvmStatic
-        fun logGetId(message: String, stacktrace: String) = useDb {
-            ExceptionTable.insertAndGetId {
-                it[ExceptionTable.server] = serverName
-                it[ExceptionTable.message] = generateMessage(message)
-                it[ExceptionTable.stackTrace] = stacktrace
-            }.value
-        }
+        fun logGetId(message: String, stacktrace: String) =
+            useDb {
+                ExceptionTable.insertAndGetId {
+                    it[ExceptionTable.server] = serverName
+                    it[ExceptionTable.message] = generateMessage(message)
+                    it[ExceptionTable.stackTrace] = stacktrace
+                }.value
+            }
 
         fun generateMessage(message: String): String {
             val msgBuilder = StringBuilder(message)

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

@@ -58,99 +58,110 @@ class SchematicNode(id: EntityID<Int>) : IntEntity(id) {
         val tabCache = mutableMapOf<Int, MutableMap<String, List<String>>>()
 
         @JvmStatic
-        fun clear() = tabCache.clear()
+        fun clear() =
+            tabCache.clear()
 
-        private fun List<SchematicNode>.mapToIds(): Map<Int, SchematicNode> = this.associateBy { it.nodeId }
+        private fun List<SchematicNode>.mapToIds(): Map<Int, SchematicNode> =
+            this.associateBy { it.nodeId }
 
         @JvmStatic
-        fun getAll(user: SteamwarUser) = fromSql(
-            "WITH RECURSIVE Nodes AS (SELECT NodeId, ParentId as ParentNode FROM NodeMember WHERE UserId = ? UNION SELECT NodeId, ParentNode FROM SchematicNode WHERE NodeOwner = ?), RSN AS ( SELECT NodeId, ParentNode FROM Nodes UNION SELECT SN.NodeId, SN.ParentNode FROM SchematicNode SN, RSN WHERE SN.ParentNode = RSN.NodeId ) SELECT SN.* FROM RSN INNER JOIN SchematicNode SN ON RSN.NodeId = SN.NodeId",
-            listOf(
-                IntegerColumnType() to user.getId(),
-                IntegerColumnType() to user.getId()
-            ),
-            fieldIndex
-        )
+        fun getAll(user: SteamwarUser) =
+            fromSql(
+                "WITH RECURSIVE Nodes AS (SELECT NodeId, ParentId as ParentNode FROM NodeMember WHERE UserId = ? UNION SELECT NodeId, ParentNode FROM SchematicNode WHERE NodeOwner = ?), RSN AS ( SELECT NodeId, ParentNode FROM Nodes UNION SELECT SN.NodeId, SN.ParentNode FROM SchematicNode SN, RSN WHERE SN.ParentNode = RSN.NodeId ) SELECT SN.* FROM RSN INNER JOIN SchematicNode SN ON RSN.NodeId = SN.NodeId",
+                listOf(
+                    IntegerColumnType() to user.getId(),
+                    IntegerColumnType() to user.getId()
+                ),
+                fieldIndex
+            )
 
         @JvmStatic
-        fun getAllMap(user: SteamwarUser) = getAll(user).mapToIds()
+        fun getAllMap(user: SteamwarUser) =
+            getAll(user).mapToIds()
 
         @JvmStatic
-        fun list(user: SteamwarUser, schematicId: Int?) = fromSql(
-            "SELECT SchematicNode.NodeId, NodeOwner, NodeName, NM.ParentId AS ParentNode, LastUpdate, NodeItem, NodeType, NodeRank, Config FROM SchematicNode INNER JOIN NodeMember NM on SchematicNode.NodeId = NM.NodeId WHERE NM.ParentId <=> ? AND NM.UserId = ? UNION ALL SELECT SchematicNode.NodeId, NodeOwner, NodeName, ParentNode, LastUpdate, NodeItem, NodeType, NodeRank, Config FROM SchematicNode WHERE (? IS NULL AND ParentNode IS NULL AND NodeOwner = ?) OR (? IS NOT NULL AND ParentNode = ?) ORDER BY NodeName",
-            listOf(
-                IntegerColumnType() to schematicId,
-                IntegerColumnType() to user.getId(),
-                IntegerColumnType() to schematicId,
-                IntegerColumnType() to user.getId(),
-                IntegerColumnType() to schematicId,
-                IntegerColumnType() to schematicId,
-            ), fieldIndex
-        )
+        fun list(user: SteamwarUser, schematicId: Int?) =
+            fromSql(
+                "SELECT SchematicNode.NodeId, NodeOwner, NodeName, NM.ParentId AS ParentNode, LastUpdate, NodeItem, NodeType, NodeRank, Config FROM SchematicNode INNER JOIN NodeMember NM on SchematicNode.NodeId = NM.NodeId WHERE NM.ParentId <=> ? AND NM.UserId = ? UNION ALL SELECT SchematicNode.NodeId, NodeOwner, NodeName, ParentNode, LastUpdate, NodeItem, NodeType, NodeRank, Config FROM SchematicNode WHERE (? IS NULL AND ParentNode IS NULL AND NodeOwner = ?) OR (? IS NOT NULL AND ParentNode = ?) ORDER BY NodeName",
+                listOf(
+                    IntegerColumnType() to schematicId,
+                    IntegerColumnType() to user.getId(),
+                    IntegerColumnType() to schematicId,
+                    IntegerColumnType() to user.getId(),
+                    IntegerColumnType() to schematicId,
+                    IntegerColumnType() to schematicId,
+                ), fieldIndex
+            )
 
         @JvmStatic
-        fun byParentName(user: SteamwarUser, schematicId: Int?, name: String) = fromSql(
-            "SELECT SchematicNode.NodeId, NodeOwner, NodeName, NM.ParentId AS ParentNode, LastUpdate, NodeItem, NodeType, NodeRank, Config FROM SchematicNode INNER JOIN NodeMember NM on SchematicNode.NodeId = NM.NodeId WHERE NM.ParentId <=> ? AND NM.UserId = ? AND SchematicNode.NodeName = ? UNION ALL SELECT SchematicNode.NodeId, NodeOwner, NodeName, ParentNode, LastUpdate, NodeItem, NodeType, NodeRank, Config FROM SchematicNode WHERE ((? IS NULL AND ParentNode IS NULL AND NodeOwner = ?) OR (? IS NOT NULL AND ParentNode = ?)) AND NodeName = ?",
-            listOf(
-                IntegerColumnType() to schematicId,
-                IntegerColumnType() to user.getId(),
-                VarCharColumnType() to name,
-                IntegerColumnType() to schematicId,
-                IntegerColumnType() to user.getId(),
-                IntegerColumnType() to schematicId,
-                IntegerColumnType() to schematicId,
-                VarCharColumnType() to name,
-            ), fieldIndex
-        ).firstOrNull()
+        fun byParentName(user: SteamwarUser, schematicId: Int?, name: String) =
+            fromSql(
+                "SELECT SchematicNode.NodeId, NodeOwner, NodeName, NM.ParentId AS ParentNode, LastUpdate, NodeItem, NodeType, NodeRank, Config FROM SchematicNode INNER JOIN NodeMember NM on SchematicNode.NodeId = NM.NodeId WHERE NM.ParentId <=> ? AND NM.UserId = ? AND SchematicNode.NodeName = ? UNION ALL SELECT SchematicNode.NodeId, NodeOwner, NodeName, ParentNode, LastUpdate, NodeItem, NodeType, NodeRank, Config FROM SchematicNode WHERE ((? IS NULL AND ParentNode IS NULL AND NodeOwner = ?) OR (? IS NOT NULL AND ParentNode = ?)) AND NodeName = ?",
+                listOf(
+                    IntegerColumnType() to schematicId,
+                    IntegerColumnType() to user.getId(),
+                    VarCharColumnType() to name,
+                    IntegerColumnType() to schematicId,
+                    IntegerColumnType() to user.getId(),
+                    IntegerColumnType() to schematicId,
+                    IntegerColumnType() to schematicId,
+                    VarCharColumnType() to name,
+                ), fieldIndex
+            ).firstOrNull()
 
         @JvmStatic
-        fun accessibleByUserType(user: SteamwarUser, type: SchematicType) = fromSql(
-            "WITH RECURSIVE Nodes AS (SELECT NodeId, ParentId as ParentNode FROM NodeMember WHERE UserId = ? UNION SELECT NodeId, ParentNode FROM SchematicNode WHERE NodeOwner = ?), RSN AS ( SELECT NodeId, ParentNode FROM Nodes UNION SELECT SN.NodeId, SN.ParentNode FROM SchematicNode SN, RSN WHERE SN.ParentNode = RSN.NodeId ) SELECT SN.*, ? AS EffectiveOwner FROM RSN INNER JOIN SchematicNode SN ON RSN.NodeId = SN.NodeId WHERE NodeType = ?",
-            listOf(
-                IntegerColumnType() to user.getId(),
-                IntegerColumnType() to user.getId(),
-                IntegerColumnType() to user.getId(),
-                VarCharColumnType() to type.toDB(),
-            ), fieldIndex
-        )
+        fun accessibleByUserType(user: SteamwarUser, type: SchematicType) =
+            fromSql(
+                "WITH RECURSIVE Nodes AS (SELECT NodeId, ParentId as ParentNode FROM NodeMember WHERE UserId = ? UNION SELECT NodeId, ParentNode FROM SchematicNode WHERE NodeOwner = ?), RSN AS ( SELECT NodeId, ParentNode FROM Nodes UNION SELECT SN.NodeId, SN.ParentNode FROM SchematicNode SN, RSN WHERE SN.ParentNode = RSN.NodeId ) SELECT SN.*, ? AS EffectiveOwner FROM RSN INNER JOIN SchematicNode SN ON RSN.NodeId = SN.NodeId WHERE NodeType = ?",
+                listOf(
+                    IntegerColumnType() to user.getId(),
+                    IntegerColumnType() to user.getId(),
+                    IntegerColumnType() to user.getId(),
+                    VarCharColumnType() to type.toDB(),
+                ), fieldIndex
+            )
 
         @JvmStatic
         fun accessibleByUserTypeMap(user: SteamwarUser, type: SchematicType) =
             accessibleByUserType(user, type).mapToIds()
 
         @JvmStatic
-        fun schematicAccessibleForUser(user: SteamwarUser, schematicId: Int?) = fromSql(
-            "WITH RECURSIVE Nodes AS (SELECT NodeId, ParentId as ParentNode FROM NodeMember WHERE UserId = ? UNION SELECT NodeId, ParentNode FROM SchematicNode WHERE NodeOwner = ?), RSN AS ( SELECT NodeId, ParentNode FROM Nodes UNION SELECT SN.NodeId, SN.ParentNode FROM SchematicNode SN, RSN WHERE SN.ParentNode = RSN.NodeId ) SELECT SN.*, ? AS EffectiveOwner FROM RSN INNER JOIN SchematicNode SN ON RSN.NodeId = SN.NodeId WHERE SN.NodeId = ?",
-            listOf(
-                IntegerColumnType() to user.getId(),
-                IntegerColumnType() to user.getId(),
-                IntegerColumnType() to user.getId(),
-                IntegerColumnType() to schematicId,
-            ),
-            fieldIndex
-        ).isNotEmpty()
+        fun schematicAccessibleForUser(user: SteamwarUser, schematicId: Int?) =
+            fromSql(
+                "WITH RECURSIVE Nodes AS (SELECT NodeId, ParentId as ParentNode FROM NodeMember WHERE UserId = ? UNION SELECT NodeId, ParentNode FROM SchematicNode WHERE NodeOwner = ?), RSN AS ( SELECT NodeId, ParentNode FROM Nodes UNION SELECT SN.NodeId, SN.ParentNode FROM SchematicNode SN, RSN WHERE SN.ParentNode = RSN.NodeId ) SELECT SN.*, ? AS EffectiveOwner FROM RSN INNER JOIN SchematicNode SN ON RSN.NodeId = SN.NodeId WHERE SN.NodeId = ?",
+                listOf(
+                    IntegerColumnType() to user.getId(),
+                    IntegerColumnType() to user.getId(),
+                    IntegerColumnType() to user.getId(),
+                    IntegerColumnType() to schematicId,
+                ),
+                fieldIndex
+            ).isNotEmpty()
 
         @JvmStatic
-        fun accessibleByUserTypeParent(user: SteamwarUser, type: SchematicType, parentId: Int?) = fromSql(
-            "WITH RECURSIVE RSASN AS(WITH RECURSIVE RSAN AS (WITH RSANH AS (WITH RECURSIVE RSA AS (SELECT SN.NodeId, NM.ParentId FROM SchematicNode SN LEFT JOIN NodeMember NM on SN.NodeId = NM.NodeId WHERE NM.UserId = ? UNION SELECT SN.NodeId, SN.ParentNode FROM SchematicNode SN INNER JOIN RSA ON RSA.NodeId = SN.ParentNode) SELECT * FROM RSA UNION SELECT NodeId, ParentNode FROM SchematicNode WHERE NodeOwner = ?) SELECT * FROM RSANH UNION SELECT SN.NodeId, SN.ParentNode FROM RSANH JOIN SchematicNode SN ON SN.ParentNode = RSANH.NodeId) SELECT RSAN.NodeId, RSAN.ParentId FROM RSAN JOIN SchematicNode SN ON SN.NodeId = RSAN.NodeId WHERE NodeType = ? UNION SELECT SN.NodeId, SN.ParentNode FROM SchematicNode SN JOIN RSASN ON SN.NodeId = RSASN.ParentId) SELECT SN.*, ? as EffectiveOwner, RSASN.ParentId AS ParentNode FROM RSASN JOIN SchematicNode SN ON SN.NodeId = RSASN.NodeId WHERE RSASN.ParentId <=> ? ORDER BY NodeName",
-            listOf(
-                IntegerColumnType() to user.getId(),
-                IntegerColumnType() to user.getId(),
-                VarCharColumnType() to type.toDB(),
-                IntegerColumnType() to user.getId(),
-                IntegerColumnType() to parentId,
-            ), fieldIndex
-        )
+        fun accessibleByUserTypeParent(user: SteamwarUser, type: SchematicType, parentId: Int?) =
+            fromSql(
+                "WITH RECURSIVE RSASN AS(WITH RECURSIVE RSAN AS (WITH RSANH AS (WITH RECURSIVE RSA AS (SELECT SN.NodeId, NM.ParentId FROM SchematicNode SN LEFT JOIN NodeMember NM on SN.NodeId = NM.NodeId WHERE NM.UserId = ? UNION SELECT SN.NodeId, SN.ParentNode FROM SchematicNode SN INNER JOIN RSA ON RSA.NodeId = SN.ParentNode) SELECT * FROM RSA UNION SELECT NodeId, ParentNode FROM SchematicNode WHERE NodeOwner = ?) SELECT * FROM RSANH UNION SELECT SN.NodeId, SN.ParentNode FROM RSANH JOIN SchematicNode SN ON SN.ParentNode = RSANH.NodeId) SELECT RSAN.NodeId, RSAN.ParentId FROM RSAN JOIN SchematicNode SN ON SN.NodeId = RSAN.NodeId WHERE NodeType = ? UNION SELECT SN.NodeId, SN.ParentNode FROM SchematicNode SN JOIN RSASN ON SN.NodeId = RSASN.ParentId) SELECT SN.*, ? as EffectiveOwner, RSASN.ParentId AS ParentNode FROM RSASN JOIN SchematicNode SN ON SN.NodeId = RSASN.NodeId WHERE RSASN.ParentId <=> ? ORDER BY NodeName",
+                listOf(
+                    IntegerColumnType() to user.getId(),
+                    IntegerColumnType() to user.getId(),
+                    VarCharColumnType() to type.toDB(),
+                    IntegerColumnType() to user.getId(),
+                    IntegerColumnType() to parentId,
+                ), fieldIndex
+            )
 
         @JvmStatic
         @Deprecated("Use byId")
-        fun byIdAndUser(ignored: SteamwarUser, id: Int) = useDb {
-            findById(id)
-        }
+        fun byIdAndUser(ignored: SteamwarUser, id: Int) =
+            useDb {
+                findById(id)
+            }
 
         @JvmStatic
-        fun parentsOfNode(user: SteamwarUser, id: Int) = fromSql(
-            """
+        fun parentsOfNode(user: SteamwarUser, id: Int) =
+            fromSql(
+                """
             WITH RECURSIVE
                 ESN_R AS (
                     SELECT SchematicNode.NodeId AS NodeId,
@@ -235,81 +246,93 @@ class SchematicNode(id: EntityID<Int>) : IntEntity(id) {
             FROM R
             INNER JOIN SchematicNode SN ON SN.NodeId = R.NodeId
             """.trimIndent(),
-            listOf(
-                IntegerColumnType() to id,
-                IntegerColumnType() to user.getId()
-            ), fieldIndex
-        )
+                listOf(
+                    IntegerColumnType() to id,
+                    IntegerColumnType() to user.getId()
+                ), fieldIndex
+            )
 
         @JvmStatic
-        fun createSchematic(owner: Int, name: String, parent: Int?) = createSchematicNode(
-            owner, name, parent,
-            SchematicType.Normal.toDB(), ""
-        )
+        fun createSchematic(owner: Int, name: String, parent: Int?) =
+            createSchematicNode(
+                owner, name, parent,
+                SchematicType.Normal.toDB(), ""
+            )
 
         @JvmStatic
         fun createSchematicDirectory(owner: Int, name: String, parent: Int?) =
             createSchematicNode(owner, name, parent, null, "")
 
         @JvmStatic
-        fun createSchematicNode(owner: Int, name: String, parent: Int?, type: String?, item: String) = useDb {
-            val id = SchematicNodeTable.insertAndGetId {
-                it[this.owner] = EntityID(owner, SteamwarUserTable)
-                it[this.name] = name
-                it[this.parent] =
-                    parent?.let { p -> if (p == 0) null else p }?.let { p -> EntityID(p, SchematicNodeTable) }
-                it[this.item] = item
-                it[this.type] = type
+        fun createSchematicNode(owner: Int, name: String, parent: Int?, type: String?, item: String) =
+            useDb {
+                val id = SchematicNodeTable.insertAndGetId {
+                    it[this.owner] = EntityID(owner, SteamwarUserTable)
+                    it[this.name] = name
+                    it[this.parent] =
+                        parent?.let { p -> if (p == 0) null else p }?.let { p -> EntityID(p, SchematicNodeTable) }
+                    it[this.item] = item
+                    it[this.type] = type
+                }
+                return@useDb findById(id)
+                    ?: throw IllegalStateException("SchematicNode $id not found")
             }
-            return@useDb findById(id) ?: throw IllegalStateException("SchematicNode $id not found")
-        }
 
         @JvmStatic
-        fun byId(id: Int) = useDb { findById(id) }
+        fun byId(id: Int) =
+            useDb { findById(id) }
 
         @JvmStatic
-        fun getSchematicNode(owner: Int, name: String, parent: Int?) = useDb {
-            find { (SchematicNodeTable.owner eq owner) and (SchematicNodeTable.name eq name) and (SchematicNodeTable.parent eq parent) }.firstOrNull()
-        }
+        fun getSchematicNode(owner: Int, name: String, parent: Int?) =
+            useDb {
+                find { (SchematicNodeTable.owner eq owner) and (SchematicNodeTable.name eq name) and (SchematicNodeTable.parent eq parent) }.firstOrNull()
+            }
 
         @JvmStatic
         fun getSchematicNode(owner: Int, name: String, parent: SchematicNode) =
             getSchematicNode(owner, name, parent.nodeId)
 
         @JvmStatic
-        fun getSchematicNodeInNode(parent: Int?) = useDb {
-            find { (SchematicNodeTable.parent eq parent) }.orderBy(SchematicNodeTable.name to SortOrder.ASC).toList()
-        }
+        fun getSchematicNodeInNode(parent: Int?) =
+            useDb {
+                find { (SchematicNodeTable.parent eq parent) }.orderBy(SchematicNodeTable.name to SortOrder.ASC).toList()
+            }
 
         @JvmStatic
-        fun getSchematicNodeInNode(parent: SchematicNode) = getSchematicNodeInNode(parent.nodeId)
+        fun getSchematicNodeInNode(parent: SchematicNode) =
+            getSchematicNodeInNode(parent.nodeId)
 
         @JvmStatic
-        fun getSchematicNode(name: String, parent: Int?) = useDb {
-            find { (SchematicNodeTable.name eq name) and (SchematicNodeTable.parent eq parent) }.firstOrNull()
-        }
+        fun getSchematicNode(name: String, parent: Int?) =
+            useDb {
+                find { (SchematicNodeTable.name eq name) and (SchematicNodeTable.parent eq parent) }.firstOrNull()
+            }
 
         @JvmStatic
-        fun getSchematicNode(id: Int) = byId(id)
+        fun getSchematicNode(id: Int) =
+            byId(id)
 
         @JvmStatic
         fun getAllAccessibleSchematicsOfType(user: Int, type: String) =
             accessibleByUserType(SteamwarUser.byId(user)!!, SchematicType.fromDB(type)!!)
 
         @JvmStatic
-        fun getAllSchematicsAccessibleByUser(user: Int) = getAll(SteamwarUser.byId(user)!!)
+        fun getAllSchematicsAccessibleByUser(user: Int) =
+            getAll(SteamwarUser.byId(user)!!)
 
         @JvmStatic
-        fun getAllSchematicsOfType(owner: Int, type: String) = useDb {
-            find { (SchematicNodeTable.owner eq owner) and (SchematicNodeTable.type eq type) }.orderBy(
-                SchematicNodeTable.name to SortOrder.ASC
-            ).toList()
-        }
+        fun getAllSchematicsOfType(owner: Int, type: String) =
+            useDb {
+                find { (SchematicNodeTable.owner eq owner) and (SchematicNodeTable.type eq type) }.orderBy(
+                    SchematicNodeTable.name to SortOrder.ASC
+                ).toList()
+            }
 
         @JvmStatic
-        fun getAllSchematicsOfType(type: SchematicType) = useDb {
-            find { (SchematicNodeTable.type eq type.toDB()) }.orderBy(SchematicNodeTable.name to SortOrder.ASC).toList()
-        }
+        fun getAllSchematicsOfType(type: SchematicType) =
+            useDb {
+                find { (SchematicNodeTable.type eq type.toDB()) }.orderBy(SchematicNodeTable.name to SortOrder.ASC).toList()
+            }
 
         @JvmStatic
         fun deepGet(parent: Int?, filter: (node: SchematicNode) -> Boolean): List<SchematicNode> =
@@ -354,9 +377,10 @@ class SchematicNode(id: EntityID<Int>) : IntEntity(id) {
         }
 
         @JvmStatic
-        fun invalidSchemName(layers: Array<String>) = layers.any {
-            it.isEmpty() || FORBIDDEN_CHARS.any { c -> c in it } || FORBIDDEN_NAMES.any { n -> n == it.lowercase() }
-        }
+        fun invalidSchemName(layers: Array<String>) =
+            layers.any {
+                it.isEmpty() || FORBIDDEN_CHARS.any { c -> c in it } || FORBIDDEN_NAMES.any { n -> n == it.lowercase() }
+            }
 
         @JvmStatic
         fun getNodeTabcomplete(user: SteamwarUser, s: String): List<String> {
@@ -372,7 +396,8 @@ class SchematicNode(id: EntityID<Int>) : IntEntity(id) {
             val list = mutableListOf<String>()
             if (s.contains("/")) {
                 val preTab = s.take(s.lastIndexOf("/") + 1)
-                val pa = getNodeFromPath(user, preTab) ?: return mutableListOf()
+                val pa = getNodeFromPath(user, preTab)
+                    ?: return mutableListOf()
                 val nodes: List<SchematicNode> = list(user, pa.getId())
                 val br = pa.generateBreadcrumbs(user)
                 nodes.forEach(Consumer { node: SchematicNode? -> list.add((if (sws) "/" else "") + br + node!!.name + (if (node.isDir()) "/" else "")) })
@@ -416,16 +441,24 @@ class SchematicNode(id: EntityID<Int>) : IntEntity(id) {
         }
     private var nodeType by SchematicNodeTable.type
     var schemtype: SchematicType
-        get() = checkDir { SchematicType.fromDB(nodeType!!) ?: SchematicType.Normal }
+        get() = checkDir {
+            SchematicType.fromDB(nodeType!!)
+                ?: SchematicType.Normal
+        }
         set(value) = checkDir { useDb { nodeType = value.toDB() } }
     var config by SchematicNodeTable.config
 
     val members: Set<NodeMember> by lazy { NodeMember.getNodeMembers(nodeId) }
     private lateinit var breadcrumbs: String
 
-    fun getFileEnding(): String = checkDir { NodeData.getLatest(this)!!.nodeFormat.fileEnding }
-    fun getId() = nodeId
-    fun isDir() = nodeType == null
+    fun getFileEnding(): String =
+        checkDir { NodeData.getLatest(this)!!.nodeFormat.fileEnding }
+
+    fun getId() =
+        nodeId
+
+    fun isDir() =
+        nodeType == null
 
     private fun <T> checkDir(block: () -> T): T {
         if (isDir()) {
@@ -435,29 +468,43 @@ class SchematicNode(id: EntityID<Int>) : IntEntity(id) {
         return block()
     }
 
-    fun replaceColor() = getConfig(ConfigFlags.REPLACE_COLOR)
-    fun setReplaceColor(value: Boolean) = setConfig(ConfigFlags.REPLACE_COLOR, value)
+    fun replaceColor() =
+        getConfig(ConfigFlags.REPLACE_COLOR)
 
-    fun allowReplay() = getConfig(ConfigFlags.ALLOW_REPLAY)
-    fun setAllowReplay(value: Boolean) = setConfig(ConfigFlags.ALLOW_REPLAY, value)
+    fun setReplaceColor(value: Boolean) =
+        setConfig(ConfigFlags.REPLACE_COLOR, value)
 
-    fun isPrepared() = getConfig(ConfigFlags.IS_PREPARED)
-    fun setPrepared(value: Boolean) = setConfig(ConfigFlags.IS_PREPARED, value)
+    fun allowReplay() =
+        getConfig(ConfigFlags.ALLOW_REPLAY)
 
-    fun getConfig(flag: ConfigFlags) = config and (1 shl flag.ordinal) != 0
-    fun setConfig(flag: ConfigFlags, value: Boolean) = useDb {
-        config = if (value) {
-            config or (1 shl flag.ordinal)
-        } else {
-            config and (1 shl flag.ordinal).inv()
+    fun setAllowReplay(value: Boolean) =
+        setConfig(ConfigFlags.ALLOW_REPLAY, value)
+
+    fun isPrepared() =
+        getConfig(ConfigFlags.IS_PREPARED)
+
+    fun setPrepared(value: Boolean) =
+        setConfig(ConfigFlags.IS_PREPARED, value)
+
+    fun getConfig(flag: ConfigFlags) =
+        config and (1 shl flag.ordinal) != 0
+
+    fun setConfig(flag: ConfigFlags, value: Boolean) =
+        useDb {
+            config = if (value) {
+                config or (1 shl flag.ordinal)
+            } else {
+                config and (1 shl flag.ordinal).inv()
+            }
         }
-    }
 
-    override fun delete() = useDb {
-        super.delete()
-    }
+    override fun delete() =
+        useDb {
+            super.delete()
+        }
 
-    override fun hashCode() = nodeId
+    override fun hashCode() =
+        nodeId
 
     override fun equals(other: Any?): Boolean {
         if (other !is SchematicNode) return false
@@ -471,44 +518,49 @@ class SchematicNode(id: EntityID<Int>) : IntEntity(id) {
         return breadcrumbs
     }
 
-    fun generateBreadcrumbs(split: String, user: SteamwarUser): String = useDb {
-        val builder: StringBuilder = StringBuilder(name)
-        if (isDir()) {
-            builder.append(split)
+    fun generateBreadcrumbs(split: String, user: SteamwarUser): String =
+        useDb {
+            val builder: StringBuilder = StringBuilder(name)
+            if (isDir()) {
+                builder.append(split)
+            }
+            var currentNode: SchematicNode? = this@SchematicNode
+            while (currentNode != null) {
+                currentNode = currentNode
+                    .let {
+                        NodeMember.getNodeMember(it.nodeId, user.getId())
+                            ?.parent?.orElse(null)
+                            ?: it.parent
+                    }
+                    ?.let { findById(it) }
+                    ?.also {
+                        builder.insert(0, split).insert(0, it.name)
+                    }
+            }
+            return@useDb builder.toString()
         }
-        var currentNode: SchematicNode? = this@SchematicNode
-        while (currentNode != null) {
-            currentNode = currentNode
-                .let {
-                    NodeMember.getNodeMember(it.nodeId, user.getId())
-                        ?.parent?.orElse(null) ?: it.parent
-                }
-                ?.let { findById(it) }
-                ?.also {
-                    builder.insert(0, split).insert(0, it.name)
-                }
-        }
-        return@useDb builder.toString()
-    }
 
-    fun generateBreadcrumbsMap(user: SteamwarUser): List<Pair<String, Int>> = useDb {
-        val map = mutableListOf<Pair<String, Int>>()
-        var currentNode: SchematicNode? = this@SchematicNode
-        while (currentNode != null) {
-            currentNode = currentNode
-                .also {
-                    map.add(0, Pair(it.name, it.nodeId))
-                }
-                .let {
-                    NodeMember.getNodeMember(it.nodeId, user.getId())
-                        ?.parent?.orElse(null) ?: it.parent
-                }
-                ?.let { findById(it) }
+    fun generateBreadcrumbsMap(user: SteamwarUser): List<Pair<String, Int>> =
+        useDb {
+            val map = mutableListOf<Pair<String, Int>>()
+            var currentNode: SchematicNode? = this@SchematicNode
+            while (currentNode != null) {
+                currentNode = currentNode
+                    .also {
+                        map.add(0, Pair(it.name, it.nodeId))
+                    }
+                    .let {
+                        NodeMember.getNodeMember(it.nodeId, user.getId())
+                            ?.parent?.orElse(null)
+                            ?: it.parent
+                    }
+                    ?.let { findById(it) }
+            }
+            return@useDb map
         }
-        return@useDb map
-    }
 
-    fun accessibleByUser(user: SteamwarUser) = schematicAccessibleForUser(user, nodeId)
+    fun accessibleByUser(user: SteamwarUser) =
+        schematicAccessibleForUser(user, nodeId)
 
     enum class ConfigFlags {
         REPLACE_COLOR,

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

@@ -27,7 +27,7 @@ import org.jetbrains.exposed.v1.core.eq
 import org.jetbrains.exposed.v1.dao.IntEntity
 import org.jetbrains.exposed.v1.dao.IntEntityClass
 
-object ScriptTable: IntIdTable("Script") {
+object ScriptTable : IntIdTable("Script") {
     val userId = reference("UserId", SteamwarUserTable).index()
     val name = varchar("Name", 64)
     val code = text("Code")
@@ -40,29 +40,35 @@ object ScriptTable: IntIdTable("Script") {
 class Script(id: EntityID<Int>) : IntEntity(id) {
     companion object : IntEntityClass<Script>(ScriptTable) {
         @JvmStatic
-        fun byId(id: Int) = useDb { findById(id) }
+        fun byId(id: Int) =
+            useDb { findById(id) }
 
         @JvmStatic
-        fun get(user: SteamwarUser, name: String) = useDb {
-            find { ScriptTable.userId eq user.id and (ScriptTable.name eq name) }.firstOrNull()
-        }
-
-        @JvmStatic
-        fun create(user: SteamwarUser, name: String, code: String) = useDb {
-            new {
-                this.userId = user.id.value
-                this.scriptName = name
-                this.scriptCode = code
+        fun get(user: SteamwarUser, name: String) =
+            useDb {
+                find { ScriptTable.userId eq user.id and (ScriptTable.name eq name) }.firstOrNull()
             }
-        }
 
         @JvmStatic
-        fun list(user: SteamwarUser) = useDb {
-            find { ScriptTable.userId eq user.id }.toList()
-        }
+        fun create(user: SteamwarUser, name: String, code: String) =
+            useDb {
+                new {
+                    this.userId = user.id.value
+                    this.scriptName = name
+                    this.scriptCode = code
+                }
+            }
+
+        @JvmStatic
+        fun list(user: SteamwarUser) =
+            useDb {
+                find { ScriptTable.userId eq user.id }.toList()
+            }
     }
 
-    fun getId() = id.value
+    fun getId() =
+        id.value
+
     var userId by ScriptTable.userId.transform({ EntityID(it, SteamwarUserTable) }, { it.value })
     private var scriptName by ScriptTable.name
     private var scriptCode by ScriptTable.code
@@ -75,5 +81,6 @@ class Script(id: EntityID<Int>) : IntEntity(id) {
         get() = scriptCode
         set(value) = useDb { scriptCode = value }
 
-    override fun delete() = useDb { super.delete() }
+    override fun delete() =
+        useDb { super.delete() }
 }

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

@@ -27,7 +27,7 @@ import org.jetbrains.exposed.v1.javatime.timestamp
 import org.jetbrains.exposed.v1.jdbc.insert
 import java.sql.Timestamp
 
-object SessionTable: Table("Session") {
+object SessionTable : Table("Session") {
     val userId = reference("UserId", SteamwarUserTable).index()
     val startTime = timestamp("StartTime")
     val endTime = timestamp("EndTime").defaultExpression(CurrentTimestamp)
@@ -35,10 +35,11 @@ object SessionTable: Table("Session") {
 
 object Session {
     @JvmStatic
-    fun insertSession(userId: Int, startTime: Timestamp) = useDb {
-        SessionTable.insert {
-            it[SessionTable.userId] = EntityID(userId, SteamwarUserTable)
-            it[SessionTable.startTime] = startTime.toInstant()
+    fun insertSession(userId: Int, startTime: Timestamp) =
+        useDb {
+            SessionTable.insert {
+                it[SessionTable.userId] = EntityID(userId, SteamwarUserTable)
+                it[SessionTable.startTime] = startTime.toInstant()
+            }
         }
-    }
 }

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

@@ -48,8 +48,8 @@ object SteamwarUserTable : IntIdTable("UserData", "id") {
     val discordId = long("DiscordId").nullable().uniqueIndex()
 }
 
-class SteamwarUser(id: EntityID<Int>): IntEntity(id) {
-    companion object: IntEntityClass<SteamwarUser>(SteamwarUserTable) {
+class SteamwarUser(id: EntityID<Int>) : IntEntity(id) {
+    companion object : IntEntityClass<SteamwarUser>(SteamwarUserTable) {
         private val random = SecureRandom()
         private val factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA512")
 
@@ -69,7 +69,7 @@ class SteamwarUser(id: EntityID<Int>): IntEntity(id) {
         @JvmStatic
         fun invalidate(userId: Int) {
             val user = byId.remove(userId)
-            if(user != null) {
+            if (user != null) {
                 byUUID.remove(user.getUUID())
                 byDiscordId.remove(user.discordId)
                 byUsername.remove(user.userName)
@@ -77,16 +77,24 @@ class SteamwarUser(id: EntityID<Int>): IntEntity(id) {
         }
 
         @JvmStatic
-        fun byId(id: Int) = byId[id] ?: useDb { findById(id)?.also { cache(it) } }
+        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) } }
+        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) } }
+        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) } }
+        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
@@ -116,34 +124,40 @@ class SteamwarUser(id: EntityID<Int>): IntEntity(id) {
                 }
 
                 newPlayer.accept(uuid)
-                get(uuid) ?: error("User $uuid not found after creation!")
+                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) }
-        }
+        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() }
+        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()
-        }
+        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
+            if (ids.isEmpty()) return
 
             useDb {
                 find { SteamwarUserTable.id inList ids }.forEach { cache(it) }
@@ -167,17 +181,22 @@ class SteamwarUser(id: EntityID<Int>): IntEntity(id) {
         set(value) = useDb {
             leaderInternal = value
         }
-    fun isLeader() = leader
+
+    fun isLeader() =
+        leader
 
     var locale: Locale by SteamwarUserTable.locale
-        .transform({ it.toLanguageTag() }, { it?.let { Locale.forLanguageTag(it) } ?: Locale.ENGLISH })
+        .transform({ it.toLanguageTag() }, {
+            it?.let { Locale.forLanguageTag(it) }
+                ?: Locale.ENGLISH
+        })
     var manualLocale by SteamwarUserTable.manualLocale
     var bedrock by SteamwarUserTable.bedrock
     private var passwordInternal by SteamwarUserTable.password
     var password: String?
         get() = passwordInternal
         set(value) {
-            if(value == null) {
+            if (value == null) {
                 useDb {
                     passwordInternal = null
                 }
@@ -200,59 +219,83 @@ class SteamwarUser(id: EntityID<Int>): IntEntity(id) {
 
     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 }
+    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 getUUID(): UUID =
+        uuid
 
-    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)
+    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
                 }
-                punishments.remove(punishment)
-                return@let false
+
+                return@let true
             }
+            ?: false
 
-            return@let true
-        } ?: false
+    fun hasPerm(perm: UserPerm) =
+        perms.contains(perm)
 
-    fun hasPerm(perm: UserPerm) = perms.contains(perm)
-    fun perms() = perms
-    fun prefix() = prefix
+    fun perms() =
+        perms
 
-    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
+    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 }
+                ?: 0.0
         }
-    }
 
-    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 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 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 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
@@ -282,7 +325,8 @@ class SteamwarUser(id: EntityID<Int>): IntEntity(id) {
         return hash.contentEquals(generateHash(password, salt))
     }
 
-    fun hasPassword() = password != null
+    fun hasPassword() =
+        password != null
 
     fun generateHash(password: String, salt: ByteArray): ByteArray =
         PBEKeySpec(password.toCharArray(), salt, 65536, 512).let { factory.generateSecret(it).encoded }

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

@@ -39,24 +39,29 @@ class Team(id: EntityID<Int>) : IntEntity(id) {
         private val teamCache = mutableMapOf<Int, Team>()
 
         @JvmStatic
-        fun clear() = synchronized(teamCache) { teamCache.clear() }
+        fun clear() =
+            synchronized(teamCache) { teamCache.clear() }
 
         @JvmStatic
-        fun byId(id: Int) = synchronized(teamCache) { teamCache.computeIfAbsent(id) { useDb { Team[id] } } }
+        fun byId(id: Int) =
+            synchronized(teamCache) { teamCache.computeIfAbsent(id) { useDb { Team[id] } } }
 
         @JvmStatic
-        fun get(name: String) = useDb { find { (TeamTable.name.lowerCase() eq name.lowercase() or (TeamTable.kuerzel.lowerCase() eq name.lowercase())) and not(TeamTable.deleted) }.firstOrNull() }
+        fun get(name: String) =
+            useDb { find { (TeamTable.name.lowerCase() eq name.lowercase() or (TeamTable.kuerzel.lowerCase() eq name.lowercase())) and not(TeamTable.deleted) }.firstOrNull() }
 
         @JvmStatic
-        fun getAll() = useDb { find { not(TeamTable.deleted) }.toList() }
+        fun getAll() =
+            useDb { find { not(TeamTable.deleted) }.toList() }
 
         @JvmStatic
-        fun create(kuerzel: String, name: String) = useDb {
-            new {
-                this.kuerzel = kuerzel
-                this.name = name
+        fun create(kuerzel: String, name: String) =
+            useDb {
+                new {
+                    this.kuerzel = kuerzel
+                    this.name = name
+                }
             }
-        }
     }
 
     val teamId by TeamTable.id.transform({ EntityID(it, TeamTable) }, { it.value })
@@ -67,13 +72,16 @@ class Team(id: EntityID<Int>) : IntEntity(id) {
         private set
     val members by lazy { useDb { SteamwarUserTable.select(SteamwarUserTable.id).where { SteamwarUserTable.team eq teamId }.map { it[SteamwarUserTable.id].value } } }
 
-    fun size() = useDb { SteamwarUser.find { SteamwarUserTable.team eq teamId }.count().toInt() }
-    fun disband(user: SteamwarUser) = useDb {
-        user.team = 0
-        deleted = true
-        teamCache.remove(teamId)
-        TeamTeilnahme.deleteFuture(teamId)
-    }
+    fun size() =
+        useDb { SteamwarUser.find { SteamwarUserTable.team eq teamId }.count().toInt() }
+
+    fun disband(user: SteamwarUser) =
+        useDb {
+            user.team = 0
+            deleted = true
+            teamCache.remove(teamId)
+            TeamTeilnahme.deleteFuture(teamId)
+        }
 
     var teamKuerzel: String
         get() = kuerzel

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

@@ -47,48 +47,55 @@ object TeamTeilnahmeTable : CompositeIdTable("TeamTeilnahme") {
 class TeamTeilnahme(id: EntityID<CompositeID>) : CompositeEntity(id) {
     companion object : CompositeEntityClass<TeamTeilnahme>(TeamTeilnahmeTable) {
         @JvmStatic
-        fun nimmtTeil(teamId: Int, eventId: Int) = useDb {
-            find { (TeamTeilnahmeTable.teamId eq teamId) and (TeamTeilnahmeTable.eventId eq eventId) }.firstOrNull() != null
-        }
-
-        @JvmStatic
-        fun teilnehmen(teamId: Int, eventId: Int) = useDb {
-            TeamTeilnahmeTable.insertIgnore {
-                it[TeamTeilnahmeTable.teamId] = teamId
-                it[TeamTeilnahmeTable.eventId] = eventId
+        fun nimmtTeil(teamId: Int, eventId: Int) =
+            useDb {
+                find { (TeamTeilnahmeTable.teamId eq teamId) and (TeamTeilnahmeTable.eventId eq eventId) }.firstOrNull() != null
             }
-        }
 
         @JvmStatic
-        fun notTeilnehmen(teamId: Int, eventId: Int) = useDb {
-            TeamTeilnahmeTable.deleteWhere { (TeamTeilnahmeTable.teamId eq teamId) and (TeamTeilnahmeTable.eventId eq eventId) }
-        }
+        fun teilnehmen(teamId: Int, eventId: Int) =
+            useDb {
+                TeamTeilnahmeTable.insertIgnore {
+                    it[TeamTeilnahmeTable.teamId] = teamId
+                    it[TeamTeilnahmeTable.eventId] = eventId
+                }
+            }
 
         @JvmStatic
-        fun deleteFuture(teamId: Int) = useDb {
-            exec(
-                "DELETE t FROM TeamTeilnahme t INNER JOIN Event e ON t.EventID = e.EventID WHERE t.TeamID = ? AND e.Start > NOW()",
-                args = listOf(IntegerColumnType() to teamId)
-            )
-        }
+        fun notTeilnehmen(teamId: Int, eventId: Int) =
+            useDb {
+                TeamTeilnahmeTable.deleteWhere { (TeamTeilnahmeTable.teamId eq teamId) and (TeamTeilnahmeTable.eventId eq eventId) }
+            }
 
         @JvmStatic
-        fun getTeams(eventId: Int) = useDb {
-            find { TeamTeilnahmeTable.eventId eq eventId }.map { Team.byId(it.teamId.value) }.toSet()
-        }
+        fun deleteFuture(teamId: Int) =
+            useDb {
+                exec(
+                    "DELETE t FROM TeamTeilnahme t INNER JOIN Event e ON t.EventID = e.EventID WHERE t.TeamID = ? AND e.Start > NOW()",
+                    args = listOf(IntegerColumnType() to teamId)
+                )
+            }
 
         @JvmStatic
-        fun getEvents(teamId: Int) = useDb {
-            find { TeamTeilnahmeTable.teamId eq teamId }.map { Event.byId(it.eventId.value) }.toSet()
-        }
+        fun getTeams(eventId: Int) =
+            useDb {
+                find { TeamTeilnahmeTable.eventId eq eventId }.map { Team.byId(it.teamId.value) }.toSet()
+            }
 
         @JvmStatic
-        fun getPlacement(team: Team, event: Event) = useDb {
-            get(CompositeID {
-                it[TeamTeilnahmeTable.teamId] = team.id
-                it[TeamTeilnahmeTable.eventId] = event.id
-            }).placement
-        }
+        fun getEvents(teamId: Int) =
+            useDb {
+                find { TeamTeilnahmeTable.teamId eq teamId }.map { Event.byId(it.eventId.value) }.toSet()
+            }
+
+        @JvmStatic
+        fun getPlacement(team: Team, event: Event) =
+            useDb {
+                get(CompositeID {
+                    it[TeamTeilnahmeTable.teamId] = team.id
+                    it[TeamTeilnahmeTable.eventId] = event.id
+                }).placement
+            }
     }
 
     val teamId by TeamTeilnahmeTable.teamId

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

@@ -32,16 +32,17 @@ import java.security.SecureRandom
 import java.sql.Timestamp
 import java.util.*
 
-object TokenTable: IntIdTable("Token") {
+object TokenTable : IntIdTable("Token") {
     val name = varchar("Name", 64).uniqueIndex()
     val owner = reference("Owner", SteamwarUserTable).index()
     val created = timestamp("Created").defaultExpression(CurrentTimestamp)
     val hash = varchar("Hash", 88).uniqueIndex()
 }
 
-class Token(id: EntityID<Int>): IntEntity(id) {
+class Token(id: EntityID<Int>) : IntEntity(id) {
     companion object : IntEntityClass<Token>(TokenTable) {
-        private fun getHash(code: String) = Base64.getEncoder().encodeToString(MessageDigest.getInstance("SHA-512").digest(code.toByteArray()))
+        private fun getHash(code: String) =
+            Base64.getEncoder().encodeToString(MessageDigest.getInstance("SHA-512").digest(code.toByteArray()))
 
         @JvmStatic
         fun createToken(name: String, owner: SteamwarUser): String {
@@ -65,17 +66,20 @@ class Token(id: EntityID<Int>): IntEntity(id) {
         }
 
         @JvmStatic
-        fun getTokenByCode(code: String) = get(getHash(code))
+        fun getTokenByCode(code: String) =
+            get(getHash(code))
 
         @JvmStatic
-        fun get(hash: String) = useDb {
-            find { TokenTable.hash eq hash }.firstOrNull()
-        }
+        fun get(hash: String) =
+            useDb {
+                find { TokenTable.hash eq hash }.firstOrNull()
+            }
 
         @JvmStatic
-        fun listUser(user: SteamwarUser) = useDb {
-            find { TokenTable.owner eq user.id }.toList()
-        }
+        fun listUser(user: SteamwarUser) =
+            useDb {
+                find { TokenTable.owner eq user.id }.toList()
+            }
     }
 
     var name by TokenTable.name
@@ -87,7 +91,8 @@ class Token(id: EntityID<Int>): IntEntity(id) {
     var hash by TokenTable.hash
         private set
 
-    override fun delete() = useDb {
-        super.delete()
-    }
+    override fun delete() =
+        useDb {
+            super.delete()
+        }
 }

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

@@ -30,7 +30,7 @@ import org.jetbrains.exposed.v1.dao.CompositeEntityClass
 import org.jetbrains.exposed.v1.jdbc.upsert
 import java.util.*
 
-object UserConfigTable: CompositeIdTable("UserConfig") {
+object UserConfigTable : CompositeIdTable("UserConfig") {
     val userId = reference("User", SteamwarUserTable)
     val config = varchar("Config", 32).entityId()
     val value = text("Value", eagerLoading = true)
@@ -42,42 +42,48 @@ object UserConfigTable: CompositeIdTable("UserConfig") {
     }
 }
 
-class UserConfig(id: EntityID<CompositeID>): CompositeEntity(id) {
+class UserConfig(id: EntityID<CompositeID>) : CompositeEntity(id) {
     val userId by UserConfigTable.userId
     val config by UserConfigTable.config
     var value by UserConfigTable.value
 
-    companion object: CompositeEntityClass<UserConfig>(UserConfigTable) {
+    companion object : CompositeEntityClass<UserConfig>(UserConfigTable) {
         @JvmStatic
-        fun getConfig(userId: Int, config: String) = useDb {
-            find { (UserConfigTable.userId eq userId) and (UserConfigTable.config eq config) }.firstOrNull()?.value
-        }
+        fun getConfig(userId: Int, config: String) =
+            useDb {
+                find { (UserConfigTable.userId eq userId) and (UserConfigTable.config eq config) }.firstOrNull()?.value
+            }
 
         @JvmStatic
-        fun getConfig(user: UUID, config: String) = getConfig(SteamwarUser.get(user)!!.id.value, config)
+        fun getConfig(user: UUID, config: String) =
+            getConfig(SteamwarUser.get(user)!!.id.value, config)
 
         @JvmStatic
-        fun updatePlayerConfig(id: Int, config: String, value: String?) = useDb {
-            if (value == null) {
-                removePlayerConfig(id, config)
-            } else {
-                UserConfigTable.upsert {
-                    it[UserConfigTable.userId] = id
-                    it[UserConfigTable.config] = config
-                    it[UserConfigTable.value] = value
+        fun updatePlayerConfig(id: Int, config: String, value: String?) =
+            useDb {
+                if (value == null) {
+                    removePlayerConfig(id, config)
+                } else {
+                    UserConfigTable.upsert {
+                        it[UserConfigTable.userId] = id
+                        it[UserConfigTable.config] = config
+                        it[UserConfigTable.value] = value
+                    }
                 }
             }
-        }
 
         @JvmStatic
-        fun updatePlayerConfig(user: UUID, config: String, value: String?) = updatePlayerConfig(SteamwarUser.get(user)!!.id.value, config, value)
+        fun updatePlayerConfig(user: UUID, config: String, value: String?) =
+            updatePlayerConfig(SteamwarUser.get(user)!!.id.value, config, value)
 
         @JvmStatic
-        fun removePlayerConfig(id: Int, config: String) = useDb {
-            find { (UserConfigTable.userId eq id) and (UserConfigTable.config eq config) }.firstOrNull()?.delete()
-        }
+        fun removePlayerConfig(id: Int, config: String) =
+            useDb {
+                find { (UserConfigTable.userId eq id) and (UserConfigTable.config eq config) }.firstOrNull()?.delete()
+            }
 
         @JvmStatic
-        fun removePlayerConfig(user: UUID, config: String) = removePlayerConfig(SteamwarUser.get(user)!!.id.value, config)
+        fun removePlayerConfig(user: UUID, config: String) =
+            removePlayerConfig(SteamwarUser.get(user)!!.id.value, config)
     }
 }

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

@@ -27,7 +27,7 @@ import org.jetbrains.exposed.v1.jdbc.deleteWhere
 import org.jetbrains.exposed.v1.jdbc.insert
 import org.jetbrains.exposed.v1.jdbc.selectAll
 
-object UserPermTable: Table("UserPerm") {
+object UserPermTable : Table("UserPerm") {
     val user = reference("User", SteamwarUserTable.id).index()
     val perm = enumerationByName("Perm", 32, UserPerm::class)
 
@@ -57,6 +57,7 @@ enum class UserPerm {
     companion object {
         @JvmField
         val emptyPrefix = Prefix("§7", "")
+
         @JvmField
         val prefixes = mapOf(
             PREFIX_NONE to emptyPrefix,
@@ -70,24 +71,27 @@ enum class UserPerm {
         )
 
         @JvmStatic
-        fun getPerms(id: Int) = useDb {
-            UserPermTable.selectAll().where { UserPermTable.user eq id }.map { it[UserPermTable.perm] }.toSet()
-        }
+        fun getPerms(id: Int) =
+            useDb {
+                UserPermTable.selectAll().where { UserPermTable.user eq id }.map { it[UserPermTable.perm] }.toSet()
+            }
 
         @JvmStatic
-        fun addPerm(user: SteamwarUser, perm: UserPerm) = useDb {
-            UserPermTable.insert {
-                it[UserPermTable.user] = user.getId()
-                it[UserPermTable.perm] = perm
+        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)
+        fun removePerm(user: SteamwarUser, perm: UserPerm) =
+            useDb {
+                UserPermTable.deleteWhere {
+                    (UserPermTable.user eq user.getId()) and (UserPermTable.perm eq perm)
+                }
             }
-        }
     }
 
     data class Prefix(val colorCode: String, val chatPrefix: String)

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

@@ -38,7 +38,7 @@ object KotlinDatabase {
     var db: Database? = null
 
     fun ensureConnected() {
-        if(db != null) return
+        if (db != null) return
 
         val file = File(System.getProperty("user.home"), "mysql.properties")
 
@@ -68,21 +68,24 @@ object KotlinDatabase {
 
 fun <T> useDb(statement: JdbcTransaction.() -> T): T {
     KotlinDatabase.ensureConnected()
-    return TransactionManager.currentOrNull()?.statement() ?: transaction(KotlinDatabase.db) {
-        statement()
-    }
+    return TransactionManager.currentOrNull()?.statement()
+        ?: transaction(KotlinDatabase.db) {
+            statement()
+        }
 }
 
 fun <T : IntEntity> IntEntityClass<T>.fromSql(
     @Language("MySQL") stmt: String,
     args: List<Pair<ColumnType<*>, Any?>>,
     fieldIndex: Map<Expression<*>, Int>
-): List<T> = useDb {
-    exec(stmt, explicitStatementType = StatementType.SELECT, args = args) {
-        val list = mutableListOf<T>()
-        while (it.next()) {
-            list.add(wrapRow(ResultRow.create(JdbcResult(it), fieldIndex)))
+): List<T> =
+    useDb {
+        exec(stmt, explicitStatementType = StatementType.SELECT, args = args) {
+            val list = mutableListOf<T>()
+            while (it.next()) {
+                list.add(wrapRow(ResultRow.create(JdbcResult(it), fieldIndex)))
+            }
+            list
         }
-        list
-    } ?: listOf()
-}
+            ?: listOf()
+    }

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

@@ -32,26 +32,30 @@ import java.sql.SQLException
 data class Statement(val statement: String) {
     companion object {
         @JvmStatic
-        fun closeAll() = KotlinDatabase.close()
+        fun closeAll() =
+            KotlinDatabase.close()
 
         @JvmStatic
-        fun productionDatabase() = TransactionManager.defaultDatabase?.name == "production"
+        fun productionDatabase() =
+            TransactionManager.defaultDatabase?.name == "production"
     }
 
-    fun <T> select(user: ResultSetUser<T>, vararg args: Any): T? = useDb {
-        exec(statement, args = args.map { getArgType(it) }) {
-            user.use(it)
+    fun <T> select(user: ResultSetUser<T>, vararg args: Any): T? =
+        useDb {
+            exec(statement, args = args.map { getArgType(it) }) {
+                user.use(it)
+            }
         }
-    }
 
-    private fun getArgType(obj: Any) = when(obj) {
-        is String -> VarCharColumnType() to obj
-        is Int -> IntegerColumnType() to obj
-        is Long -> LongColumnType() to obj
-        is Boolean -> BooleanColumnType() to obj
-        is SteamwarUser -> IntegerColumnType() to obj.id.value
-        else -> error("Unknown type: ${obj::class.simpleName}")
-    }
+    private fun getArgType(obj: Any) =
+        when (obj) {
+            is String -> VarCharColumnType() to obj
+            is Int -> IntegerColumnType() to obj
+            is Long -> LongColumnType() to obj
+            is Boolean -> BooleanColumnType() to obj
+            is SteamwarUser -> IntegerColumnType() to obj.id.value
+            else -> error("Unknown type: ${obj::class.simpleName}")
+        }
 
     interface ResultSetUser<T> {
         @Throws(SQLException::class)