Merge pull request #4 from nathanfallet/fix/repo-instead-of-singleton

Fix: using repo instead of singleton

settings.gradle.kts

@@ -17,6 +17,7 @@ include(":zabricraft-datetime")
 include(":zabricraft-bcrypt")
 include(":zabricraft-exposed")
 include(":zabricraft-mysql")
+include(":zabricraft-h2")
 include(":zabricraft-koin")
 include(":zabricraft-runtime")
 

zabricraft-core/build.gradle.kts

@@ -25,6 +25,14 @@ kotlin {
 }
 
 dependencies {
-    compileOnly("org.spigotmc:spigot-api:1.20.2-R0.1-SNAPSHOT")
+    implementation("org.spigotmc:spigot-api:1.20.2-R0.1-SNAPSHOT")
+
     api(project(":zabricraft-runtime"))
+
+    testImplementation(kotlin("test"))
+    testImplementation("io.mockk:mockk:1.13.8")
+}
+
+tasks.test {
+    useJUnitPlatform()
 }

zabricraft-core/src/main/kotlin/me/nathanfallet/zabricraft/Core.kt

@@ -1,5 +1,6 @@
 package me.nathanfallet.zabricraft
 
+import me.nathanfallet.usecases.models.list.IListModelUseCase
 import me.nathanfallet.zabricraft.commands.auth.LoginCommand
 import me.nathanfallet.zabricraft.commands.auth.RegisterCommand
 import me.nathanfallet.zabricraft.commands.leaderboards.LeaderboardCommand
@@ -13,16 +14,19 @@ import me.nathanfallet.zabricraft.events.core.ServerPing
 import me.nathanfallet.zabricraft.events.games.SignChange
 import me.nathanfallet.zabricraft.events.players.*
 import me.nathanfallet.zabricraft.events.rules.WorldProtection
-import me.nathanfallet.zabricraft.usecases.core.IGetSetMessageUseCase
-import me.nathanfallet.zabricraft.usecases.games.IGetAddGamesUseCase
+import me.nathanfallet.zabricraft.models.leaderboards.Leaderboard
+import me.nathanfallet.zabricraft.usecases.core.ISetMessageUseCase
+import me.nathanfallet.zabricraft.usecases.games.IClearGamesUseCase
+import me.nathanfallet.zabricraft.usecases.games.IListGameUseCase
 import me.nathanfallet.zabricraft.usecases.games.IUpdateGameUseCase
 import me.nathanfallet.zabricraft.usecases.leaderboards.*
 import me.nathanfallet.zabricraft.usecases.players.IClearZabriPlayersCacheUseCase
 import me.nathanfallet.zabricraft.usecases.players.ICreateUpdateZabriPlayerUseCase
 import me.nathanfallet.zabricraft.usecases.players.IUpdateOnlinePlayersUseCase
-import me.nathanfallet.zabricraft.usecases.rules.IGetWorldProtectionRulesUseCase
+import me.nathanfallet.zabricraft.usecases.rules.IAddWorldProtectionRuleUseCase
+import me.nathanfallet.zabricraft.usecases.rules.IClearWorldProtectionRuleUseCase
 import me.nathanfallet.zabricraft.usecases.rules.IWorldProtectionRuleUseCase
-import me.nathanfallet.zabricraft.usecases.scoreboards.IGetGenerateScoreboardsUseCase
+import me.nathanfallet.zabricraft.usecases.scoreboards.IClearGenerateScoreboardUseCase
 import org.bukkit.Bukkit
 import org.bukkit.configuration.file.YamlConfiguration
 import org.bukkit.plugin.java.JavaPlugin
@@ -44,14 +48,14 @@ class Core : JavaPlugin() {
             return
         }
 
-        val getSetMessageUseCase = get().get<IGetSetMessageUseCase>()
+        val setMessageUseCase = get().get<ISetMessageUseCase>()
         val messagesFile = File(dataFolder, "messages.yml")
         if (!messagesFile.exists()) {
             saveResource("messages.yml", false)
         }
         val messages = YamlConfiguration.loadConfiguration(messagesFile)
         messages.getKeys(false).forEach { id ->
-            getSetMessageUseCase(id, messages.getString(id) ?: "")
+            setMessageUseCase(id, messages.getString(id) ?: "")
         }
 
         val createUpdateZabriPlayerUseCase = get().get<ICreateUpdateZabriPlayerUseCase>()
@@ -61,14 +65,14 @@ class Core : JavaPlugin() {
 
         clearCustomEntities()
 
-        val getWorldProtectionRuleUseCase = get().get<IGetWorldProtectionRulesUseCase>()
+        val addWorldProtectionRuleUseCase = get().get<IAddWorldProtectionRuleUseCase>()
         if (config.getBoolean("server.spawn_protection")) {
-            getWorldProtectionRuleUseCase().add(get().get<IWorldProtectionRuleUseCase>(named("spawn_protection")))
+            addWorldProtectionRuleUseCase(get().get<IWorldProtectionRuleUseCase>(named("spawn_protection")))
         }
 
-        val getGenerateLeaderboardsUseCase = get().get<IGetGenerateLeaderboardsUseCase>()
+        val setGenerateLeaderboardUseCase = get().get<ISetGenerateLeaderboardUseCase>()
         listOf("money", "score", "victories").forEach {
-            getGenerateLeaderboardsUseCase()[it] = get().get<IGenerateLeaderboardUseCase>(named(it))
+            setGenerateLeaderboardUseCase(it, get().get<IGenerateLeaderboardUseCase>(named(it)))
         }
 
         Bukkit.getPluginManager().registerEvents(get().get<PlayerAuthentication>(), this)
@@ -88,44 +92,40 @@ class Core : JavaPlugin() {
         getCommand("spawn")?.setExecutor(get().get<SpawnCommand>())
         getCommand("setspawn")?.setExecutor(get().get<SetSpawnCommand>())
 
-        val getAddGamesUseCase = get().get<IGetAddGamesUseCase>()
+        val listGameUseCase = get().get<IListGameUseCase>()
         val updateGameUseCase = get().get<IUpdateGameUseCase>()
         val updateOnlinePlayersUseCase = get().get<IUpdateOnlinePlayersUseCase>()
-        val getLeaderboardsUseCase = get().get<IGetLeaderboardsUseCase>()
+        val listLeaderboardUseCase = get().get<IListModelUseCase<Leaderboard>>(named<Leaderboard>())
         val saveLeaderboardsUseCase = get().get<ISaveLeaderboardsUseCase>()
         val updateLeaderboardUseCase = get().get<IUpdateLeaderboardUseCase>()
         Bukkit.getScheduler().scheduleSyncRepeatingTask(this, {
-            getAddGamesUseCase().forEach { updateGameUseCase(it) }
+            listGameUseCase().forEach { updateGameUseCase(it) }
             updateOnlinePlayersUseCase()
-            getLeaderboardsUseCase().values.forEach { updateLeaderboardUseCase(it) }
+            listLeaderboardUseCase().forEach { updateLeaderboardUseCase(it) }
         }, 0, 20)
         Bukkit.getScheduler().scheduleSyncRepeatingTask(this, {
             saveLeaderboardsUseCase()
         }, 6000, 6000)
     }
 
     override fun onDisable() {
-        val getAddGamesUseCase = get().get<IGetAddGamesUseCase>()
-        getAddGamesUseCase().forEach { it.reset() }
-        getAddGamesUseCase.clear()
+        val clearGameUseCase = get().get<IClearGamesUseCase>()
+        clearGameUseCase()
 
         val clearZabriPlayersCacheUseCase = get().get<IClearZabriPlayersCacheUseCase>()
         clearZabriPlayersCacheUseCase()
 
-        val getLeaderboardsUseCase = get().get<IGetLeaderboardsUseCase>()
         val saveLeaderboardsUseCase = get().get<ISaveLeaderboardsUseCase>()
+        val clearLeaderboardUseCase = get().get<IClearLeaderboardsUseCase>()
         saveLeaderboardsUseCase()
-        getLeaderboardsUseCase().forEach { (_, leaderboard) ->
-            leaderboard.kill()
-        }
-        getLeaderboardsUseCase.clear()
-
-        val getWorldProtectionRuleUseCase = get().get<IGetWorldProtectionRulesUseCase>()
-        val getGenerateLeaderboardsUseCase = get().get<IGetGenerateLeaderboardsUseCase>()
-        val getGenerateScoreboardsUseCase = get().get<IGetGenerateScoreboardsUseCase>()
-        getWorldProtectionRuleUseCase.clear()
-        getGenerateLeaderboardsUseCase.clear()
-        getGenerateScoreboardsUseCase.clear()
+        clearLeaderboardUseCase()
+
+        val getWorldProtectionRuleUseCase = get().get<IClearWorldProtectionRuleUseCase>()
+        val clearGenerateLeaderboardUseCase = get().get<IClearGenerateLeaderboardUseCase>()
+        val getGenerateScoreboardsUseCase = get().get<IClearGenerateScoreboardUseCase>()
+        getWorldProtectionRuleUseCase()
+        clearGenerateLeaderboardUseCase()
+        getGenerateScoreboardsUseCase()
 
         val database = get().get<Database>()
         database.disconnect()

zabricraft-core/src/main/kotlin/me/nathanfallet/zabricraft/commands/leaderboards/LeaderboardCommand.kt

@@ -1,25 +1,35 @@
 package me.nathanfallet.zabricraft.commands.leaderboards
 
+import me.nathanfallet.usecases.models.create.ICreateModelUseCase
+import me.nathanfallet.usecases.models.delete.IDeleteModelUseCase
+import me.nathanfallet.usecases.models.get.IGetModelUseCase
+import me.nathanfallet.usecases.models.list.IListModelUseCase
+import me.nathanfallet.usecases.models.update.IUpdateModelUseCase
+import me.nathanfallet.zabricraft.models.leaderboards.CreateLeaderboardPayload
 import me.nathanfallet.zabricraft.models.leaderboards.Leaderboard
-import me.nathanfallet.zabricraft.usecases.leaderboards.IGetGenerateLeaderboardsUseCase
-import me.nathanfallet.zabricraft.usecases.leaderboards.IGetLeaderboardsUseCase
+import me.nathanfallet.zabricraft.models.leaderboards.UpdateLeaderboardPayload
+import me.nathanfallet.zabricraft.usecases.leaderboards.IListGenerateLeaderboardUseCase
 import org.bukkit.ChatColor
 import org.bukkit.command.Command
 import org.bukkit.command.CommandExecutor
 import org.bukkit.command.CommandSender
 import org.bukkit.entity.Player
 
 class LeaderboardCommand(
-    private val getLeaderboardsUseCase: IGetLeaderboardsUseCase,
-    private val getGenerateLeaderboardsUseCase: IGetGenerateLeaderboardsUseCase
+    private val listLeaderboardUseCase: IListModelUseCase<Leaderboard>,
+    private val createLeaderboardsUseCase: ICreateModelUseCase<Leaderboard, CreateLeaderboardPayload>,
+    private val getLeaderboardUseCase: IGetModelUseCase<Leaderboard, String>,
+    private val updateLeaderboardUseCase: IUpdateModelUseCase<Leaderboard, String, UpdateLeaderboardPayload>,
+    private val deleteLeaderboardUseCase: IDeleteModelUseCase<Leaderboard, String>,
+    private val getGenerateLeaderboardsUseCase: IListGenerateLeaderboardUseCase
 ) : CommandExecutor {
 
     override fun onCommand(sender: CommandSender, cmd: Command, label: String, args: Array<String>): Boolean {
         when (args.getOrNull(0)?.lowercase()) {
             "list" -> {
                 sender.sendMessage(ChatColor.YELLOW.toString() + "------ " + ChatColor.GOLD + "Classements existants " + ChatColor.YELLOW + "------")
-                getLeaderboardsUseCase().forEach {
-                    sender.sendMessage(ChatColor.GOLD.toString() + it.key + ChatColor.YELLOW + " : " + it.value.type)
+                listLeaderboardUseCase().forEach {
+                    sender.sendMessage(ChatColor.GOLD.toString() + it.id + ChatColor.YELLOW + " : " + it.type)
                 }
             }
 
@@ -36,65 +46,55 @@ class LeaderboardCommand(
                     sender.sendMessage(ChatColor.RED.toString() + "/leaderboard create <nom> <type>")
                     return true
                 }
-                if (getLeaderboardsUseCase().containsKey(args[1])) {
+                createLeaderboardsUseCase(CreateLeaderboardPayload(args[1], sender.location, args[2], 10)) ?: run {
                     sender.sendMessage(ChatColor.RED.toString() + "Le classement " + ChatColor.DARK_RED + args[1] + ChatColor.RED + " existe déjà !")
                     return true
                 }
-                val leaderboard = Leaderboard(
-                    sender.location,
-                    args[2], 10
-                )
-                getLeaderboardsUseCase()[args[1]] = leaderboard
                 sender.sendMessage(ChatColor.GREEN.toString() + "Le classement " + ChatColor.YELLOW + args[1] + ChatColor.GREEN + " a bien été créé !")
             }
 
             "info" -> args.getOrNull(1)?.let { key ->
-                leaderboard(key, sender)?.let { leaderboard ->
-                    sender.sendMessage(ChatColor.GOLD.toString() + key + " : " + ChatColor.YELLOW + leaderboard.type)
-                } ?: Unit
+                val leaderboard = getLeaderboardUseCase(key) ?: run {
+                    sender.sendMessage(ChatColor.RED.toString() + "Le classement " + ChatColor.DARK_RED + key + ChatColor.RED + " n'existe pas !")
+                    return true
+                }
+                sender.sendMessage(ChatColor.GOLD.toString() + key + " : " + ChatColor.YELLOW + leaderboard.type)
             } ?: sender.sendMessage(ChatColor.RED.toString() + "/leaderboard info <nom>")
 
 
             "remove" -> args.getOrNull(1)?.let { key ->
-                leaderboard(key, sender)?.let { leaderboard ->
-                    getLeaderboardsUseCase().remove(key)
-                    leaderboard.kill()
-                    sender.sendMessage(ChatColor.GREEN.toString() + "Le classement " + ChatColor.YELLOW + key + ChatColor.GREEN + " a bien été supprimé !")
-                } ?: Unit
+                if (!deleteLeaderboardUseCase(key)) {
+                    sender.sendMessage(ChatColor.RED.toString() + "Le classement " + ChatColor.DARK_RED + key + ChatColor.RED + " n'existe pas !")
+                    return true
+                }
+                sender.sendMessage(ChatColor.GREEN.toString() + "Le classement " + ChatColor.YELLOW + key + ChatColor.GREEN + " a bien été supprimé !")
             } ?: sender.sendMessage(ChatColor.RED.toString() + "/leaderboard remove <nom>")
 
 
             "settype" -> args.getOrNull(1)?.let { key ->
                 val type = args.getOrNull(2) ?: return@let null
-                leaderboard(key, sender)?.let { leaderboard ->
-                    getLeaderboardsUseCase()[key] = leaderboard.copy(type = type)
-                    leaderboard.kill()
-                    sender.sendMessage(ChatColor.GREEN.toString() + "Le classement " + ChatColor.YELLOW + key + ChatColor.GREEN + " est maintenant de type " + type + " !")
-                } ?: Unit
+                if (updateLeaderboardUseCase(key, UpdateLeaderboardPayload(type = type)) == null) {
+                    sender.sendMessage(ChatColor.RED.toString() + "Le classement " + ChatColor.DARK_RED + key + ChatColor.RED + " n'existe pas !")
+                    return true
+                }
+                sender.sendMessage(ChatColor.GREEN.toString() + "Le classement " + ChatColor.YELLOW + key + ChatColor.GREEN + " est maintenant de type " + type + " !")
             } ?: sender.sendMessage(ChatColor.RED.toString() + "/leaderboard settype <nom> <type>")
 
 
             "setlimit" -> args.getOrNull(1)?.let { key ->
                 val limit = args.getOrNull(2)?.toInt() ?: return@let null
-                leaderboard(key, sender)?.let { leaderboard ->
-                    getLeaderboardsUseCase()[key] = leaderboard.copy(limit = limit)
-                    leaderboard.kill()
-                    sender.sendMessage(ChatColor.GREEN.toString() + "Le classement " + ChatColor.YELLOW + key + ChatColor.GREEN + " a maintenant " + limit + " lignes !")
-                } ?: Unit
+                if (updateLeaderboardUseCase(key, UpdateLeaderboardPayload(limit = limit)) == null) {
+                    sender.sendMessage(ChatColor.RED.toString() + "Le classement " + ChatColor.DARK_RED + key + ChatColor.RED + " n'existe pas !")
+                    return true
+                }
+                sender.sendMessage(ChatColor.GREEN.toString() + "Le classement " + ChatColor.YELLOW + key + ChatColor.GREEN + " a maintenant " + limit + " lignes !")
             } ?: sender.sendMessage(ChatColor.RED.toString() + "/leaderboard setlimit <nom> <limit>")
 
             else -> sendHelp(sender)
         }
         return true
     }
 
-    private fun leaderboard(key: String, sender: CommandSender): Leaderboard? {
-        return getLeaderboardsUseCase()[key] ?: run {
-            sender.sendMessage(ChatColor.RED.toString() + "Le classement " + ChatColor.DARK_RED + key + ChatColor.RED + " n'existe pas !")
-            null
-        }
-    }
-
     private fun sendHelp(sender: CommandSender) {
         sender.sendMessage(
             """

zabricraft-core/src/main/kotlin/me/nathanfallet/zabricraft/commands/spawn/SpawnCommand.kt

@@ -1,21 +1,20 @@
 package me.nathanfallet.zabricraft.commands.spawn
 
-import me.nathanfallet.zabricraft.usecases.players.IGetBukkitPlayerByNameUseCase
 import me.nathanfallet.zabricraft.usecases.spawn.IGetSetSpawnUseCase
+import org.bukkit.Bukkit
 import org.bukkit.ChatColor
 import org.bukkit.command.Command
 import org.bukkit.command.CommandExecutor
 import org.bukkit.command.CommandSender
 import org.bukkit.entity.Player
 
 class SpawnCommand(
-    private val getBukkitPlayerByNameUseCase: IGetBukkitPlayerByNameUseCase,
     private val getSetSpawnUseCase: IGetSetSpawnUseCase
 ) : CommandExecutor {
 
     override fun onCommand(sender: CommandSender, cmd: Command, label: String, args: Array<String>): Boolean {
         if (args.size == 1 && sender.hasPermission("zabricraft.spawn.others")) {
-            getBukkitPlayerByNameUseCase(args[0])?.takeIf { it.isOnline }?.let { player ->
+            Bukkit.getPlayer(args[0])?.takeIf { it.isOnline }?.let { player ->
                 player.sendMessage(ChatColor.GOLD.toString() + "Téléportation au spawn...")
                 player.teleport(getSetSpawnUseCase())
             }

zabricraft-core/src/main/kotlin/me/nathanfallet/zabricraft/database/players/DatabaseZabriPlayersRepository.kt

@@ -53,7 +53,7 @@ class DatabaseZabriPlayersRepository(
         }
     }
 
-    override fun getAll(): List<ZabriPlayer> {
+    override fun list(): List<ZabriPlayer> {
         return database.dbQuery {
             ZabriPlayers
                 .selectAll()
@@ -63,6 +63,17 @@ class DatabaseZabriPlayersRepository(
         }
     }
 
+    override fun list(limit: Long, offset: Long): List<ZabriPlayer> {
+        return database.dbQuery {
+            ZabriPlayers
+                .selectAll()
+                .limit(limit.toInt(), offset)
+                .map {
+                    ZabriPlayers.toZabriPlayer(it, getCached(it[ZabriPlayers.id].value))
+                }
+        }
+    }
+
     override fun getTopMoney(limit: Int): List<ZabriPlayer> {
         return database.dbQuery {
             ZabriPlayers