create mock

2024-09-19 04:41:41 +09:00
parent ebdc854fd6
commit d518640ab3
13 changed files with 881 additions and 0 deletions
@@ -0,0 +1,188 @@
+package net.hareworks.kommandlib
+
+import kotlin.collections.listOf
+import org.bukkit.Bukkit
+import org.bukkit.command.CommandMap
+import org.bukkit.command.CommandSender
+import org.bukkit.command.PluginCommand
+import org.bukkit.command.TabCompleter
+import org.bukkit.plugin.java.JavaPlugin
+
+class KommandLib(plugin: JavaPlugin, vararg routes: Pair<String, Argument>) {
+  val routes = routes.toMap()
+  init {
+    val f = Bukkit.getServer().javaClass.getDeclaredField("commandMap")
+    f.isAccessible = true
+    val commandMap = f.get(Bukkit.getServer()) as CommandMap
+    for ((name, _) in routes) {
+      commandMap.register(
+          plugin.getName(),
+          (PluginCommand::class
+                  .java
+                  .declaredConstructors
+                  .first()
+                  .apply { isAccessible = true }
+                  .newInstance(name, plugin) as
+                  PluginCommand)
+              .apply {
+                this.name = name
+                this.setExecutor { sender, _, alias, args ->
+                  val route = getLastRoute(arrayOf(alias, *args))
+                  if (route.size == args.size + 1) route.last().onCommand(sender, args)
+                  true
+                }
+                this.tabCompleter = TabCompleter { sender, _, alias, args ->
+                  val route = getLastRoute(arrayOf(alias, *args))
+                  if (route.size == args.size) route.last().getCompletList(sender, args)
+                  else listOf()
+                }
+              }
+      )
+    }
+  }
+
+  fun getLastRoute(args: Array<String>): List<Argument> {
+    val list = mutableListOf<Argument>(routes[args[0]] ?: throw Exception("Invalid command"))
+    var i = 1
+    while (i + 1 <= args.size) {
+      if (list.last().routes.isEmpty()) break
+      val route =
+          list.last().routes.values.sortedBy { it.priority }.find { it.typeCheck(args[i]) } ?: break
+      list.add(route)
+      i += route.unit
+    }
+    return list
+  }
+
+  fun unregister() {
+    val f = Bukkit.getServer().javaClass.getDeclaredField("commandMap")
+    f.isAccessible = true
+    val commandMap = f.get(Bukkit.getServer()) as CommandMap
+    for ((name, _) in routes) {
+      commandMap.getCommand(name)?.unregister(commandMap)
+    }
+  }
+}
+
+abstract class Argument(
+    vararg routes: Pair<String, Argument>,
+    val execute: (CommandSender, Array<Any>) -> Unit
+) {
+  val routes = routes.toMap()
+  var name: String = ""
+    get() = field
+    protected set(value) {
+      field = value
+    }
+  var permission: String = ""
+    set(value) {
+      field = value
+      if (value.isEmpty()) return
+      for ((_, route) in routes) {
+        route.permission = value + "." + route.name
+      }
+    }
+
+  init {
+    for ((name, route) in routes) {
+      route.name = name
+    }
+  }
+
+  abstract var priority: Int
+  open var unit: Int = 1
+  abstract fun onCommand(sender: CommandSender, args: Array<String>)
+  abstract fun typeCheck(arg: String): Boolean
+  abstract fun toValue(args: Array<String>): Any
+
+  abstract fun suggest(sender: CommandSender, args: Array<String>): List<String>
+
+  fun getCompletList(sender: CommandSender, args: Array<String>): List<String> {
+    return routes
+        .values
+        .filter { sender.hasPermission(it.permission) }
+        .map { it.suggest(sender, args) }
+        .flatten()
+  }
+}
+
+class Route(vararg routes: Pair<String, Argument>, execute: (CommandSender, Array<Any>) -> Unit) :
+    Argument(*routes, execute = execute) {
+  override var priority: Int = 2
+  override fun onCommand(sender: CommandSender, args: Array<String>) {
+    execute(sender, args.map { it }.toTypedArray())
+  }
+  override fun typeCheck(arg: String): Boolean {
+    return this.name == arg
+  }
+  override fun toValue(args: Array<String>): Any {
+    return args.joinToString(" ")
+  }
+
+  override fun suggest(sender: CommandSender, args: Array<String>): List<String> {
+    return if (sender.hasPermission(this.permission) && this.name.startsWith(args.last()))
+        listOf(this.name)
+    else listOf()
+  }
+}
+
+class Text(vararg routes: Pair<String, Argument>, execute: (CommandSender, Array<Any>) -> Unit) :
+    Argument(*routes, execute = execute) {
+  override var priority: Int = 0
+  override fun typeCheck(arg: String): Boolean {
+    return true
+  }
+  override fun toValue(args: Array<String>): Any {
+    return args.joinToString(" ")
+  }
+  override fun onCommand(sender: CommandSender, args: Array<String>) {
+    execute(sender, args.map { it }.toTypedArray())
+  }
+
+  override fun suggest(sender: CommandSender, args: Array<String>): List<String> {
+    return listOf(args.last())
+  }
+}
+
+class Integer(vararg routes: Pair<String, Argument>, execute: (CommandSender, Array<Any>) -> Unit) :
+    Argument(*routes, execute = execute) {
+  override var priority: Int = 1
+  override fun typeCheck(arg: String): Boolean {
+    return arg.toIntOrNull() != null
+  }
+
+  override fun onCommand(sender: CommandSender, args: Array<String>) {
+    execute(sender, args.map { it.toInt() }.toTypedArray())
+  }
+
+  override fun toValue(args: Array<String>): Any {
+    return args[0].toInt()
+  }
+
+  override fun suggest(sender: CommandSender, args: Array<String>): List<String> {
+    return listOf()
+  }
+}
+
+class Position(
+    vararg routes: Pair<String, Argument>,
+    execute: (CommandSender, Array<Any>) -> Unit
+) : Argument(*routes, execute = execute) {
+  override var priority: Int = 3
+  override var unit: Int = 3
+  override fun typeCheck(arg: String): Boolean {
+    return true
+  }
+
+  override fun onCommand(sender: CommandSender, args: Array<String>) {
+    execute(sender, args.map { it }.toTypedArray())
+  }
+
+  override fun toValue(args: Array<String>): Any {
+    return Triple(args[0].toDouble(), args[1].toDouble(), args[2].toDouble())
+  }
+
+  override fun suggest(sender: CommandSender, args: Array<String>): List<String> {
+    return listOf()
+  }
+}
@@ -0,0 +1,43 @@
+package net.hareworks.simplymcdb
+
+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
+
+public class App : JavaPlugin() {
+  public var enabled: Boolean = false
+    private set
+  companion object {
+    lateinit var instance: App
+      private set
+  }
+  lateinit var command: KommandLib
+    private set
+  override fun onEnable() {
+    instance = this
+    logger.info("simplymcdb enabled.")
+
+    initConfig()
+    Database.connect()
+    command = KommandLib(this, "smcdb" to smcdb)
+  }
+  override fun onDisable() {
+    enabled = false
+    Database.disconnect()
+    command.unregister()
+    logger.info("simplymcdb disabled.")
+  }
+
+  public fun enable() {
+    enabled = true
+    logger.info("simplymcdb enabled.")
+  }
+
+  public fun disable() {
+    enabled = false
+    logger.info("simplymcdb disabled.")
+    Database.disconnect()
+  }
+}
@@ -0,0 +1,81 @@
+package net.hareworks.simplymcdb.command
+
+import net.hareworks.kommandlib.*
+import net.hareworks.simplymcdb.App
+import net.hareworks.simplymcdb.config.reload as reloadConfig
+import net.kyori.adventure.text.minimessage.MiniMessage
+import org.bukkit.entity.Player
+
+public val smcdb: Route =
+ Route(
+   "config" to
+    Route(
+      "reload" to
+       Route { sender, _ ->
+         sender.sendMessage("reloading config...")
+         reloadConfig()
+         sender.sendMessage("reloaded.")
+       }
+        .apply {
+          permission =
+           "simplydb.command.config.reload"
+        },
+      "fetch" to
+       Route { sender, _ ->
+         sender.sendMessage("fetching config...")
+       }
+        .apply {
+          permission =
+           "simplydb.command.config.fetch"
+        },
+      "upload" to
+       Route { sender, _ ->
+         sender.sendMessage("uploading config...")
+       }
+        .apply {
+          permission =
+           "simplydb.command.config.upload"
+        },
+      "help" to
+       Route { sender, _ ->
+         var help =
+          MiniMessage.miniMessage()
+           .deserialize(
+            """<red>simplymcdb config help
+<gray>reload: <green>reload the config from config.yml
+<gray>fetch: <green>fetch the config from the database
+<gray>upload: <green>upload the current config to the database
+"""
+           )
+         sender.sendMessage(help)
+       }
+        .apply {
+          permission =
+           "simplydb.command.config"
+        }
+     ) { sender, _ ->
+      (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
+      }
+      App.instance.enable()
+      sender.sendMessage("simplymcdb enabled.")
+    }
+     .apply { permission = "simplydb.command.on" },
+   "off" to
+    Route { sender, _ ->
+      if (!App.instance.enabled) {
+        sender.sendMessage("simplymcdb is already disabled.")
+        return@Route
+      }
+      App.instance.disable()
+      sender.sendMessage("simplymcdb disabled.")
+    }
+     .apply { permission = "simplydb.command.off" },
+  ) { sender, _ -> sender.sendMessage("simplymcdb command") }
+  .apply { permission = "simplydb.command" }
@@ -0,0 +1,16 @@
+package net.hareworks.simplymcdb.config
+
+import net.hareworks.simplymcdb.App
+import org.bukkit.configuration.file.YamlConfiguration
+
+public val config: YamlConfiguration = YamlConfiguration()
+
+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.")
+}
@@ -0,0 +1,17 @@
+package net.hareworks.simplymcdb.event
+
+import net.hareworks.simplymcdb.App
+import org.bukkit.event.Listener
+import org.bukkit.event.EventHandler
+import org.bukkit.event.player.PlayerJoinEvent
+import net.kyori.adventure.text.minimessage.MiniMessage
+
+public object EventListener : Listener {
+  @EventHandler
+  fun onJoin(event: PlayerJoinEvent) {
+    if (event.player.hasPermission("simplymcdb.admin") || !App.instance.enabled) {
+      val mm = MiniMessage.miniMessage().deserialize("<red>simplymcdb is disabled.")
+      event.player.sendMessage(mm)
+    }
+  }
+}
@@ -0,0 +1,8 @@
+package net.hareworks.simplymcdb.playerdata
+
+public class PlayerData {
+  override fun toString() : String {
+    return "PlayerData"
+  }
+}
+  
@@ -0,0 +1,81 @@
+package net.hareworks.simplymcdb.database
+
+import net.hareworks.simplymcdb.App
+import net.hareworks.simplymcdb.config.config
+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
+  public fun connect() {
+    val type = config.getString("database.type")
+    val host = config.getString("database.host")
+    val port = config.getInt("database.port")
+    val database = config.getString("database.database")
+    val user = config.getString("database.user")
+    val password = config.getString("database.password")
+    if (type == null || host == null || database == null || user == null || password == null) {
+      App.instance.logger.warning("Database configuration is invalid")
+      return
+    }
+    try {
+      instance =
+              when (type) {
+                "mysql" ->
+                        Database.connect(
+                                "jdbc:mysql://$host:$port/$database",
+                                "com.mysql.cj.jdbc.Driver",
+                                user,
+                                password
+                        )
+                "postgresql" ->
+                        Database.connect(
+                                "jdbc:postgresql://$host:$port/$database",
+                                "org.postgresql.Driver",
+                                user,
+                                password
+                        )
+                else -> {
+                  App.instance.logger.warning("Database type is invalid")
+                  return
+                }
+              }
+    } catch (e: Exception) {
+      App.instance.logger.warning("Database connection failed")
+      e.printStackTrace()
+    }
+    if (instance == null) return
+    App.instance.logger.info("Database connected: $host:$port/$database")
+    transaction { addLogger(StdOutSqlLogger)
+      SchemaUtils.create(Players)
+      Players.selectAll().forEach {
+        App.instance.logger.info(it[Players.name])
+      }
+    }
+  }
+  public fun disconnect() {
+    instance?.let {
+      it.connector().close()
+      instance = null
+      App.instance.logger.info("Database disconnected")
+      return
+    }
+    App.instance.logger.warning("Database is not connected")
+  }
+}