build.gradle.kts

@@ -7,7 +7,6 @@ val exposedVersion = "0.54.0"
 
 plugins {
     kotlin("jvm") version "2.0.20"
-    kotlin("plugin.serialization") version "2.0.20"
     id("net.minecrell.plugin-yml.bukkit") version "0.6.0"
     id("com.github.johnrengelman.shadow") version "8.1.1"
 }
@@ -19,7 +18,6 @@ dependencies {
     compileOnly("io.papermc.paper:paper-api:1.21.1-R0.1-SNAPSHOT")
     implementation("net.kyori:adventure-api:4.17.0")
     implementation("net.kyori:adventure-text-minimessage:4.17.0")
-    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.1")
     implementation("org.postgresql:postgresql:42.7.1")
     implementation("org.jetbrains.exposed:exposed-core:$exposedVersion")
     implementation("org.jetbrains.exposed:exposed-dao:$exposedVersion")

src/main/kotlin/net/hareworks/kommandlib/main.kt

@@ -70,6 +70,10 @@ abstract class Argument(
 ) {
   val routes = routes.toMap()
   var name: String = ""
+    get() = field
+    protected set(value) {
+      field = value
+    }
   var permission: String = ""
     set(value) {
       field = value
@@ -77,9 +81,7 @@ abstract class Argument(
       for ((_, route) in routes) {
         route.permission = value + "." + route.name
       }
-      println("permission setted to $value")
     }
-    var condition: (CommandSender) -> Boolean = { true }
 
   init {
     for ((name, route) in routes) {
@@ -98,7 +100,7 @@ abstract class Argument(
   fun getCompletList(sender: CommandSender, args: Array<String>): List<String> {
     return routes
         .values
-        .filter { sender.hasPermission(it.permission) && it.condition(sender) }
+        .filter { sender.hasPermission(it.permission) }
         .map { it.suggest(sender, args) }
         .flatten()
   }
@@ -118,7 +120,7 @@ class Route(vararg routes: Pair<String, Argument>, execute: (CommandSender, Arra
   }
 
   override fun suggest(sender: CommandSender, args: Array<String>): List<String> {
-    return if (sender.hasPermission(this.permission) && this.condition(sender) && this.name.startsWith(args.last()))
+    return if (sender.hasPermission(this.permission) && this.name.startsWith(args.last()))
         listOf(this.name)
     else listOf()
   }

src/main/kotlin/net/hareworks/simplymcdb/App.kt

@@ -1,23 +1,14 @@
 package net.hareworks.simplymcdb
 
-import net.hareworks.simplymcdb.Config
+import net.hareworks.simplymcdb.config.init as initConfig
 import net.hareworks.simplymcdb.database.Database
 import net.hareworks.simplymcdb.command.smcdb
 import net.hareworks.kommandlib.KommandLib
 import org.bukkit.plugin.java.JavaPlugin
 
-enum class State {
-  ACTIVE,
-  DISCONNECTED,
-  DISABLED
-}
-
 public class App : JavaPlugin() {
-  public var enabled: State = State.DISABLED
+  public var enabled: Boolean = false
-    private set(value) {
+    private set
-      field = value
-      Config.config.set("enabled", !value.equals(State.DISABLED))
-    }
   companion object {
     lateinit var instance: App
       private set
@@ -28,29 +19,25 @@ public class App : JavaPlugin() {
     instance = this
     logger.info("simplymcdb enabled.")
 
-    Config.init()
+    initConfig()
+    Database.connect()
     command = KommandLib(this, "smcdb" to smcdb)
   }
   override fun onDisable() {
-    enabled = State.DISABLED
+    enabled = false
     Database.disconnect()
     command.unregister()
     logger.info("simplymcdb disabled.")
   }
 
   public fun enable() {
-    Database.connect()
+    enabled = true
-    if (Database.instance == null) {
-      enabled = State.DISCONNECTED
-      return
-    }
     logger.info("simplymcdb enabled.")
-    enabled = State.ACTIVE
   }
 
   public fun disable() {
-    Database.disconnect()
+    enabled = false
     logger.info("simplymcdb disabled.")
-    enabled = State.DISABLED
+    Database.disconnect()
   }
 }

src/main/kotlin/net/hareworks/simplymcdb/Command.kt

@@ -2,118 +2,80 @@ package net.hareworks.simplymcdb.command
 
 import net.hareworks.kommandlib.*
 import net.hareworks.simplymcdb.App
-import net.hareworks.simplymcdb.State
 import net.hareworks.simplymcdb.config.reload as reloadConfig
-import net.hareworks.simplymcdb.database.Database
 import net.kyori.adventure.text.minimessage.MiniMessage
+import org.bukkit.entity.Player
 
 public val smcdb: Route =
-  Route(
+ Route(
-      "config" to
+   "config" to
-        Route(
+    Route(
-            "reload" to
+      "reload" to
-              Route { sender, _ ->
+       Route { sender, _ ->
-                sender.sendMessage("reloading config...")
+         sender.sendMessage("reloading config...")
-                reloadConfig()
+         reloadConfig()
-                sender.sendMessage("reloaded.")
+         sender.sendMessage("reloaded.")
-              }
+       }
-                .apply {
+        .apply {
-                  permission =
+          permission =
-                    "simplydb.command.config.reload"
+           "simplydb.command.config.reload"
-                },
+        },
-            "fetch" to
+      "fetch" to
-              Route { sender, _ ->
+       Route { sender, _ ->
-                sender.sendMessage("fetching config...")
+         sender.sendMessage("fetching config...")
-              }
+       }
-                .apply {
+        .apply {
-                  permission =
+          permission =
-                    "simplydb.command.config.fetch"
+           "simplydb.command.config.fetch"
-                },
+        },
-            "upload" to
+      "upload" to
-              Route { sender, _ ->
+       Route { sender, _ ->
-                sender.sendMessage("uploading config...")
+         sender.sendMessage("uploading config...")
-              }
+       }
-                .apply {
+        .apply {
-                  permission =
+          permission =
-                    "simplydb.command.config.upload"
+           "simplydb.command.config.upload"
-                },
+        },
-            "help" to
+      "help" to
-              Route { sender, _ ->
+       Route { sender, _ ->
-                var help =
+         var help =
-                  MiniMessage.miniMessage()
-                    .deserialize(
-                      "<red>simplymcdb config help<newline><gray>reload: <green>reload the config from config.yml<newline><gray>fetch: <green>fetch the config from the database<newline><gray>upload: <green>upload the current config to the database"
-                    )
-                sender.sendMessage(help)
-              }
-                .apply {
-                  permission =
-                    "simplydb.command.config"
-                },
-            "on" to
-              Route { sender, _ ->
-                if (App.instance.enabled == State.ACTIVE
-                ) {
-                  sender.sendMessage(
-                    "simplymcdb is already enabled."
-                  )
-                  return@Route
-                }
-                App.instance.enable()
-                sender.sendMessage("simplymcdb enabled.")
-              }
-                .apply {
-                  permission = "simplydb.command.config.on"
-                },
-            "off" to
-              Route { sender, _ ->
-                if (App.instance.enabled != State.ACTIVE
-                ) {
-                  sender.sendMessage(
-                    "simplymcdb is already disabled."
-                  )
-                  return@Route
-                }
-                App.instance.disable()
-                sender.sendMessage("simplymcdb disabled.")
-              }
-                .apply {
-                  permission =
-                    "simplydb.command.config.off"
-                },
-          ) { sender, _ ->
-          (sender as   ).performCommand("smcdb config help")
-        }
-          .apply { permission = "simplydb.command.config" },
-      "help" to Route { sender, _ ->
-        var help =
           MiniMessage.miniMessage()
-            .deserialize(
+           .deserialize(
-              "<red>simplymcdb help<newline><gray>config: <green>configre the plugin<newline><gray>activate: <green>when the plugin is disabled, activate it<newline><gray>deactivate: <green>when the plugin is enabled, deactivate it"
+            """<red>simplymcdb config help
-            )
+<gray>reload: <green>reload the config from config.yml
-        sender.sendMessage(help)
+<gray>fetch: <green>fetch the config from the database
-      }
+<gray>upload: <green>upload the current config to the database
-        .apply { permission = "simplydb.command" },
+"""
-      "activate" to Route { sender, _ ->
+           )
-        if (App.instance.enabled == State.ACTIVE
+         sender.sendMessage(help)
-        ) {
+       }
-          sender.sendMessage(
+        .apply {
-            "simplymcdb is already enabled."
+          permission =
-          )
+           "simplydb.command.config"
-          return@Route
         }
-        App.instance.enable()
+     ) { sender, _ ->
-        sender.sendMessage("simplymcdb enabled.")
+      (sender as Player).performCommand("smcdb config help")
+    }
+     .apply { permission = "simplydb.command.config" },
+   "on" to
+    Route { sender, _ ->
+      if (App.instance.enabled) {
+        sender.sendMessage("simplymcdb is already enabled.")
+        return@Route
       }
-        .apply { permission = "simplydb.command.activate" },
+      App.instance.enable()
-      "initialize" to Route { sender, _ ->
+      sender.sendMessage("simplymcdb enabled.")
-        sender.sendMessage("database initializing...")
+    }
-        Database.initialize()
+     .apply { permission = "simplydb.command.on" },
+   "off" to
+    Route { sender, _ ->
+      if (!App.instance.enabled) {
+        sender.sendMessage("simplymcdb is already disabled.")
+        return@Route
       }
-        .apply { permission = "simplydb.command.setup" },
+      App.instance.disable()
-      "confirm" to Route { sender, _ ->
+      sender.sendMessage("simplymcdb disabled.")
-        
+    }
-      }
+     .apply { permission = "simplydb.command.off" },
-        .apply { permission = "simplydb.command.confirm" },
+  ) { sender, _ -> sender.sendMessage("simplymcdb command") }
-    ) { sender, _ -> sender.sendMessage("simplymcdb command") }
+  .apply { permission = "simplydb.command" }
-    .apply { name = "simplymcdb" }

src/main/kotlin/net/hareworks/simplymcdb/Config.kt

@@ -1,37 +1,16 @@
-package net.hareworks.simplymcdb
+package net.hareworks.simplymcdb.config
 
+import net.hareworks.simplymcdb.App
 import org.bukkit.configuration.file.YamlConfiguration
-import org.jetbrains.exposed.sql.Table
 
+public val config: YamlConfiguration = YamlConfiguration()
 
-object ConfigTable : Table() {
+public fun init() {
-  val uuid = varchar("uuid", 36)
+  App.instance.saveDefaultConfig()
-  val name = varchar("name", 16)
+  config.load(App.instance.dataFolder.resolve("config.yml"))
-  val lastLogin = long("last_login")
-  val lastLogout = long("last_logout")
-  val playTime = long("play_time")
-  val firstLogin = long("first_login")
-  val lastIp = varchar("last_ip", 15)
-  val lastServer = varchar("last_server", 255)
-
-  override val primaryKey = PrimaryKey(uuid)
 }
 
-public object Config {
+public fun reload() {
-  public val config: YamlConfiguration = YamlConfiguration()
+  config.load(App.instance.dataFolder.resolve("config.yml"))
-
+  App.instance.logger.info("config reloaded.")
-  public fun init() {
-    App.instance.saveDefaultConfig()
-    config.load(App.instance.dataFolder.resolve("config.yml"))
-  }
-
-  public fun reload() {
-    config.load(App.instance.dataFolder.resolve("config.yml"))
-    App.instance.logger.info("config reloaded.")
-  }
-
-  public fun save() {
-    config.save(App.instance.dataFolder.resolve("config.yml"))
-    App.instance.logger.info("config saved.")
-  }
 }

src/main/kotlin/net/hareworks/simplymcdb/Event.kt

@@ -1,42 +1,17 @@
 package net.hareworks.simplymcdb.event
 
 import net.hareworks.simplymcdb.App
-import net.hareworks.simplymcdb.State
-import net.hareworks.simplymcdb.database.Database
-import net.kyori.adventure.text.minimessage.MiniMessage
-import org.bukkit.event.EventHandler
 import org.bukkit.event.Listener
+import org.bukkit.event.EventHandler
 import org.bukkit.event.player.PlayerJoinEvent
-import org.jetbrains.exposed.sql.*
+import net.kyori.adventure.text.minimessage.MiniMessage
-import org.jetbrains.exposed.sql.transactions.transaction
 
 public object EventListener : Listener {
   @EventHandler
   fun onJoin(event: PlayerJoinEvent) {
-    if (event.player.hasPermission("simplymcdb.admin")) {
+    if (event.player.hasPermission("simplymcdb.admin") || !App.instance.enabled) {
-      when (App.instance.enabled) {
+      val mm = MiniMessage.miniMessage().deserialize("<red>simplymcdb is disabled.")
-        State.DISABLED -> {
+      event.player.sendMessage(mm)
-          val mm = MiniMessage.miniMessage().deserialize("<red>simplymcdb is disabled.")
-          event.player.sendMessage(mm)
-        }
-        State.DISCONNECTED -> {
-          val mm = MiniMessage.miniMessage().deserialize("<red>simplymcdb is enabled but disconnected.<br><gray>Check the database connection and try /smcdb on.")
-          event.player.sendMessage(mm)
-        }
-        else -> {
-          val mm = MiniMessage.miniMessage().deserialize("<green>simplymcdb is enabled.")
-          event.player.sendMessage(mm)
-        }
-      }
-    }
-    if (App.instance.enabled == State.ACTIVE) {
-      val player = event.player
-      // if player has already registered in the database, load the data
-      Database.instance?.let {
-        transaction(it) {
-          
-        }
-      }
     }
   }
 }

src/main/kotlin/net/hareworks/simplymcdb/PlayerData.kt

@@ -1,49 +1,8 @@
 package net.hareworks.simplymcdb.playerdata
 
-import net.hareworks.simplymcdb.App
+public class PlayerData {
-import net.hareworks.simplymcdb.database.Database
+  override fun toString() : String {
-import org.bukkit.entity.Player as BukkitPlayer
+    return "PlayerData"
-import org.jetbrains.exposed.sql.*
-import org.jetbrains.exposed.sql.transactions.transaction
-
-public object Player : Table() {
-  val uuid = varchar("uuid", 36)
-  val name = varchar("name", 16)
-  val lastLogin = long("last_login")
-  val lastLogout = long("last_logout")
-  val playTime = long("play_time")
-  val firstLogin = long("first_login")
-  val lastIp = varchar("last_ip", 15)
-
-  val data = text("data").nullable()
-
-  override val primaryKey = PrimaryKey(uuid)
-}
-
-public fun register(player: BukkitPlayer) {
-  App.instance.logger.info("Registering player data for ${player.name}")
-  Database.instance?.let {
-    transaction {
-      Player.insert {
-        it[uuid] = player.uniqueId.toString()
-        it[name] = player.name
-        it[lastLogin] = System.currentTimeMillis()
-        it[firstLogin] = System.currentTimeMillis()
-        it[lastIp] = player.address?.address?.hostAddress ?: "unknown"
-      }
-    }
   }
 }
   
-public fun push(player: BukkitPlayer) {
-  App.instance.logger.info("Creating player data for ${player.name}")
-  Database.instance?.let {
-    transaction {
-      Player.update({ Player.uuid eq player.uniqueId.toString() }) {
-        it[lastLogin] = System.currentTimeMillis()
-        it[lastIp] = player.address?.address?.hostAddress ?: "unknown"
-        
-      }
-    }
-  }
-}

src/main/kotlin/net/hareworks/simplymcdb/PlayerSerializer.kt

@@ -1,31 +0,0 @@
-package net.hareworks.simplymcdb
-
-import org.bukkit.entity.Player as BukkitPlayer
-import org.bukkit.inventory.ItemStack
-
-class PlayerInventory(
-  val contents: Array<ItemStack>,
-  val armor: Array<ItemStack>,
-)
-
-object PlayerSerializer {
-  fun serialize(player: BukkitPlayer): String {
-    val inv = player.inventory.storageContents
-    val armor = player.inventory.armorContents
-    val enderChest = player.enderChest
-
-    return "" // base64 encoded string
-  }
-
-  fun deserialize(data: String): Map<String, Any> {
-    return mapOf()
-  }
-}
-
-fun ItemStacksToBase64(item: Array<ItemStack>): String {
-  return ""
-}
-
-fun fromBase64(data: String): ByteArray {
-  return byteArrayOf()
-}

src/main/kotlin/net/hareworks/simplymcdb/database/Database.kt

@@ -2,11 +2,24 @@ package net.hareworks.simplymcdb.database
 
 import net.hareworks.simplymcdb.App
 import net.hareworks.simplymcdb.config.config
-import net.hareworks.simplymcdb.playerdata.Player
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.Database
+import org.jetbrains.exposed.sql.Table
 import org.jetbrains.exposed.sql.transactions.transaction
 
+object Players : Table() {
+  val uuid = varchar("uuid", 36)
+  val name = varchar("name", 16)
+  val lastLogin = long("last_login")
+  val lastLogout = long("last_logout")
+  val playTime = long("play_time")
+  val firstLogin = long("first_login")
+  val lastIp = varchar("last_ip", 15)
+  val lastServer = varchar("last_server", 255)
+
+  override val primaryKey = PrimaryKey(uuid)
+}
+
 public object Database {
   public var instance: Database? = null
     private set
@@ -49,10 +62,11 @@ public object Database {
     }
     if (instance == null) return
     App.instance.logger.info("Database connected: $host:$port/$database")
-    if (!ping()) {
+    transaction { addLogger(StdOutSqlLogger)
-      App.instance.logger.warning("Database ping failed")
+      SchemaUtils.create(Players)
-    } else {
+      Players.selectAll().forEach {
-      App.instance.logger.info("Database ping successful")
+        App.instance.logger.info(it[Players.name])
+      }
     }
   }
   public fun disconnect() {
@@ -64,22 +78,4 @@ public object Database {
     }
     App.instance.logger.warning("Database is not connected")
   }
-
-  public fun ping(): Boolean {
-    return try {
-      transaction {
-        addLogger(StdOutSqlLogger)
-        exec("SELECT 1")
-      }
-      true
-    } catch (e: Exception) {
-      false
-    }
-  }
-
-  public fun initialize() {
-    transaction {
-      SchemaUtils.create(Player)
-    }
-  }
 }

src/main/resources/config.yml

@@ -6,13 +6,3 @@ database:
   database: smcdb
   user: smcdb
   password: SaN1m_wk2eh9
-playerdata:
-  health: true
-  hunger: true
-  experience: true
-  status: true
-  inventory: true
-  enderchest: true
-  # achievements: true
-  # recipebook: true
-  gamemode: true