Push new version 1.4.9.2 change with updating player names before caching.

Author: EncryptSL

gradle.properties

@@ -1,6 +1,6 @@
 #Plugin Settings
 plugin_name=LiteEco
-plugin_version=1.4.9.1-SNAPSHOT
+plugin_version=1.4.9.2-SNAPSHOT
 plugin_description=LiteEco is an economy plugin using VaultAPI
 
 #Server Dependency

src/main/kotlin/com/github/encryptsl/lite/eco/api/interfaces/PlayerSQL.kt

@@ -7,8 +7,8 @@ import java.util.concurrent.CompletableFuture
 
 interface PlayerSQL {
     fun createPlayerAccount(username: String, uuid: UUID, currency: String, money: BigDecimal)
+    fun updatePlayerName(uuid: UUID, username: String, currency: String)
     fun getUserByUUID(uuid: UUID, currency: String): CompletableFuture<User>
-    fun setPlayerNames(currency: String)
     fun deletePlayerAccount(uuid: UUID, currency: String)
     fun getExistPlayerAccount(uuid: UUID, currency: String): CompletableFuture<Boolean>
     fun getTopBalance(currency: String): MutableMap<String, User>

src/main/kotlin/com/github/encryptsl/lite/eco/common/database/models/DatabaseEcoModel.kt

@@ -33,6 +33,18 @@ class DatabaseEcoModel : PlayerSQL {
         }
     }
 
+    override fun updatePlayerName(uuid: UUID, username: String, currency: String) {
+        loggedTransaction {
+            try {
+                val table = Account(currency)
+                table.update ({ table.uuid eq uuid }) {
+                }
+            } catch (e : ExposedSQLException) {
+                LiteEco.instance.logger.severe(e.message ?: e.localizedMessage)
+            }
+        }
+    }
+
     override fun getUserByUUID(uuid: UUID, currency: String): CompletableFuture<User> {
         val future = CompletableFuture<User>()
         loggedTransaction {
@@ -53,22 +65,6 @@ class DatabaseEcoModel : PlayerSQL {
         return future
     }
 
-    override fun setPlayerNames(currency: String) {
-        val offlinePlayers = Bukkit.getOfflinePlayers()
-        for (player in offlinePlayers) {
-            loggedTransaction {
-                try {
-                    val table = Account(currency)
-                    table.update({ table.uuid eq player.uniqueId }) {
-                        it[username] = player.name.toString()
-                    }
-                } catch (e : ExposedSQLException) {
-                    LiteEco.instance.logger.severe(e.message ?: e.localizedMessage)
-                }
-            }
-        }
-    }
-
     override fun deletePlayerAccount(uuid: UUID, currency: String) {
         loggedTransaction {
             try {

src/main/kotlin/com/github/encryptsl/lite/eco/listeners/AccountManageListener.kt

@@ -21,8 +21,13 @@ class AccountManageListener(private val liteEco: LiteEco) : Listener {
             }
             OperationType.CACHING_ACCOUNT -> {
                 for (currency in liteEco.currencyImpl.getCurrenciesKeys()) {
-                    liteEco.databaseEcoModel.getUserByUUID(player.uniqueId, currency)
-                        .thenAccept { liteEco.api.cacheAccount(player, currency, it.money) }
+                    liteEco.databaseEcoModel.getUserByUUID(player.uniqueId, currency).thenApply {
+                        liteEco.databaseEcoModel.updatePlayerName(it.uuid, player.name.toString(), currency)
+
+                        return@thenApply it
+                    }.thenAccept {
+                        liteEco.api.cacheAccount(player, currency, it.money)
+                    }
                 }
             }
             OperationType.SYNC_ACCOUNT -> liteEco.api.syncAccount(player)

src/main/kotlin/com/github/encryptsl/lite/eco/utils/PlayerUtils.kt

@@ -2,20 +2,15 @@ package com.github.encryptsl.lite.eco.utils
 
 import org.bukkit.Bukkit
 import org.bukkit.OfflinePlayer
-import org.bukkit.entity.Entity
-import java.util.Optional
-import java.util.UUID
+import org.bukkit.entity.Player
+import java.util.*
 
 object PlayerUtils {
     fun getOfflinePlayer(uuid: UUID): OfflinePlayer {
         return Bukkit.getPlayer(uuid) ?: Bukkit.getOfflinePlayer(uuid)
     }
 
     fun getUniqueId(offlinePlayer: OfflinePlayer): UUID {
-        return Optional.ofNullable(offlinePlayer.getPlayer()).map(Entity::getUniqueId).orElseGet(offlinePlayer::getUniqueId)
-    }
-
-    fun getUniqueId(player: String): UUID {
-        return getUniqueId(Bukkit.getOfflinePlayer(player))
+        return Optional.ofNullable(offlinePlayer.player).map(Player::getUniqueId).orElseGet(offlinePlayer::getUniqueId)
     }
 }