moved logic components into shared

modules/dto/src/main/kotlin/ru/astrainteractive/astrarating/model/PlayerModel.kt

@@ -0,0 +1,5 @@
+package ru.astrainteractive.astrarating.model
+
+import java.util.UUID
+
+data class PlayerModel(val uuid: UUID, val name: String)

modules/shared/build.gradle.kts

@@ -0,0 +1,19 @@
+plugins {
+    kotlin("jvm")
+    kotlin("plugin.serialization")
+}
+
+dependencies {
+    // Kotlin
+    implementation(libs.bundles.kotlin)
+    // AstraLibs
+    implementation(libs.minecraft.astralibs.ktxcore)
+    // klibs
+    implementation(libs.klibs.mikro)
+    // Test
+    testImplementation(libs.bundles.testing.kotlin)
+    testImplementation(libs.tests.kotlin.test)
+    // Local
+    implementation(projects.modules.apiRating)
+    implementation(projects.modules.dto)
+}

modules/shared/src/main/kotlin/ru/astrainteractive/astrarating/feature/allrating/AllRatingsComponent.kt

@@ -0,0 +1,16 @@
+package ru.astrainteractive.astrarating.feature.allrating
+
+import kotlinx.coroutines.flow.StateFlow
+import ru.astrainteractive.astrarating.dto.UserAndRating
+import ru.astrainteractive.astrarating.model.UsersRatingsSort
+
+interface AllRatingsComponent {
+    val model: StateFlow<Model>
+    fun onSortClicked()
+    fun close()
+
+    data class Model(
+        val userRatings: List<UserAndRating> = emptyList(),
+        val sort: UsersRatingsSort = UsersRatingsSort.ASC
+    )
+}

modules/shared/src/main/kotlin/ru/astrainteractive/astrarating/feature/allrating/DefaultAllRatingsComponent.kt

@@ -0,0 +1,40 @@
+package ru.astrainteractive.astrarating.feature.allrating
+
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import ru.astrainteractive.astralibs.async.AsyncComponent
+import ru.astrainteractive.astrarating.api.rating.api.RatingDBApi
+import ru.astrainteractive.astrarating.model.UsersRatingsSort
+import ru.astrainteractive.klibs.mikro.core.dispatchers.KotlinDispatchers
+import ru.astrainteractive.klibs.mikro.core.util.next
+
+class DefaultAllRatingsComponent(
+    private val dbApi: RatingDBApi,
+    dispatchers: KotlinDispatchers
+) : AllRatingsComponent, AsyncComponent() {
+    override val model = MutableStateFlow(AllRatingsComponent.Model())
+
+    override fun onSortClicked() {
+        val nextSort = model.value.sort.next(UsersRatingsSort.values())
+        val userRatings = model.value.userRatings
+        val sortedUserRatings = if (nextSort == UsersRatingsSort.ASC) {
+            userRatings.sortedBy { it.rating.rating }
+        } else {
+            userRatings.sortedByDescending { it.rating.rating }
+        }
+        model.update {
+            it.copy(userRatings = sortedUserRatings)
+        }
+    }
+
+    init {
+        componentScope.launch(dispatchers.IO) {
+            val userRatings = dbApi.fetchUsersTotalRating().getOrDefault(emptyList())
+            model.update {
+                it.copy(userRatings = userRatings)
+            }
+            onSortClicked()
+        }
+    }
+}

modules/shared/src/main/kotlin/ru/astrainteractive/astrarating/feature/playerrating/DefaultPlayerRatingsComponent.kt

@@ -0,0 +1,64 @@
+package ru.astrainteractive.astrarating.feature.playerrating
+
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import ru.astrainteractive.astralibs.async.AsyncComponent
+import ru.astrainteractive.astrarating.api.rating.api.RatingDBApi
+import ru.astrainteractive.astrarating.dto.UserAndRating
+import ru.astrainteractive.astrarating.model.PlayerModel
+import ru.astrainteractive.astrarating.model.UserRatingsSort
+import ru.astrainteractive.klibs.mikro.core.dispatchers.KotlinDispatchers
+import ru.astrainteractive.klibs.mikro.core.util.next
+
+class DefaultPlayerRatingsComponent(
+    playerModel: PlayerModel,
+    private val dbApi: RatingDBApi,
+    private val dispatchers: KotlinDispatchers
+) : PlayerRatingsComponent, AsyncComponent() {
+    override val model = MutableStateFlow(
+        PlayerRatingsComponent.Model(playerModel = playerModel)
+    )
+
+    override fun onSortClicked() {
+        componentScope.launch(dispatchers.IO) {
+            val newSort = model.value.sort.next(UserRatingsSort.values())
+            val previousUserRatings = model.value.userRatings
+            val newUserRatings = when (newSort) {
+                UserRatingsSort.DATE_ASC -> previousUserRatings.sortedBy { it.rating.time }
+                UserRatingsSort.DATE_DESC -> previousUserRatings.sortedByDescending { it.rating.time }
+                UserRatingsSort.PLAYER_ASC -> previousUserRatings.sortedBy { it.userCreatedReport.id }
+                UserRatingsSort.PLAYER_DESC -> previousUserRatings.sortedByDescending { it.userCreatedReport.id }
+                UserRatingsSort.RATING_ASC -> previousUserRatings.sortedBy { it.rating.rating }
+                UserRatingsSort.RATING_DESC -> previousUserRatings.sortedBy { it.rating.rating }
+            }
+            model.update {
+                it.copy(
+                    sort = newSort,
+                    userRatings = newUserRatings
+                )
+            }
+        }
+    }
+
+    override fun onDeleteClicked(item: UserAndRating) {
+        componentScope.launch(dispatchers.IO) {
+            dbApi.deleteUserRating(item.rating)
+        }
+    }
+
+    private fun reload() {
+        componentScope.launch(dispatchers.IO) {
+            val playerModel = model.value.playerModel
+            val userRatings = dbApi.fetchUserRatings(playerModel.name).getOrDefault(emptyList())
+            model.update {
+                it.copy(userRatings = userRatings)
+            }
+            onSortClicked()
+        }
+    }
+
+    init {
+        reload()
+    }
+}

modules/shared/src/main/kotlin/ru/astrainteractive/astrarating/feature/playerrating/PlayerRatingsComponent.kt

@@ -0,0 +1,18 @@
+package ru.astrainteractive.astrarating.feature.playerrating
+
+import kotlinx.coroutines.flow.StateFlow
+import ru.astrainteractive.astrarating.dto.UserAndRating
+import ru.astrainteractive.astrarating.model.PlayerModel
+import ru.astrainteractive.astrarating.model.UserRatingsSort
+
+interface PlayerRatingsComponent {
+    val model: StateFlow<Model>
+    fun onSortClicked()
+    fun onDeleteClicked(item: UserAndRating)
+    fun close()
+    data class Model(
+        val playerModel: PlayerModel,
+        val userRatings: List<UserAndRating> = emptyList(),
+        val sort: UserRatingsSort = UserRatingsSort.values().first()
+    )
+}

settings.gradle.kts

@@ -46,3 +46,4 @@ include("modules:db-rating")
 include("modules:api-rating")
 include("modules:dto")
 include("modules:integration-papi")
+include("modules:shared")

spigot/build.gradle.kts

@@ -32,6 +32,7 @@ dependencies {
     implementation(projects.modules.apiRating)
     implementation(projects.modules.dto)
     implementation(projects.modules.integrationPapi)
+    implementation(projects.modules.shared)
 }
 val localFolder = File("D:\\Minecraft Servers\\Servers\\esmp-configuration\\smp\\plugins")
 if (localFolder.exists()) setupSpigotShadow(localFolder) else setupSpigotShadow()

spigot/src/main/kotlin/ru/astrainteractive/astrarating/di/impl/GuiModuleImpl.kt

@@ -25,7 +25,7 @@ class GuiModuleImpl(rootModule: RootModule) : GuiModule {
         )
     }
 
-    override fun playerRatingsGuiFactory(
+    override fun allRatingsGuiFactory(
         selectedPlayer: OfflinePlayer,
         player: Player
     ): Factory<PlayerRatingsGUI> = Factory {

spigot/src/main/kotlin/ru/astrainteractive/astrarating/gui/playerratings/PlayerRatingsGUI.kt

@@ -14,8 +14,11 @@ import ru.astrainteractive.astralibs.menu.holder.PlayerHolder
 import ru.astrainteractive.astralibs.menu.menu.InventorySlot
 import ru.astrainteractive.astralibs.menu.menu.MenuSize
 import ru.astrainteractive.astralibs.menu.menu.PaginatedMenu
+import ru.astrainteractive.astrarating.feature.playerrating.DefaultPlayerRatingsComponent
+import ru.astrainteractive.astrarating.feature.playerrating.PlayerRatingsComponent
 import ru.astrainteractive.astrarating.gui.playerratings.di.PlayerRatingGuiModule
-import ru.astrainteractive.astrarating.gui.ratings.RatingsGUIViewModel
+import ru.astrainteractive.astrarating.gui.util.PlayerHeadUtil
+import ru.astrainteractive.astrarating.model.PlayerModel
 import ru.astrainteractive.astrarating.plugin.AstraPermission
 import ru.astrainteractive.astrarating.util.TimeUtility
 import ru.astrainteractive.astrarating.util.desc
@@ -33,7 +36,14 @@ class PlayerRatingsGUI(
     private val clickListener = MenuClickListener()
     override val playerHolder: PlayerHolder = DefaultPlayerHolder(player)
 
-    private val viewModel = PlayerRatingsGUIViewModel(selectedPlayer, module)
+    private val playerRatingsComponent: PlayerRatingsComponent = DefaultPlayerRatingsComponent(
+        playerModel = PlayerModel(
+            uuid = selectedPlayer.uniqueId,
+            name = selectedPlayer.name ?: selectedPlayer.uniqueId.toString()
+        ),
+        dbApi = module.dbApi,
+        dispatchers = module.dispatchers
+    )
 
     override var menuTitle: String = translation.playerRatingTitle.replace("%player%", selectedPlayer.name ?: "")
     override val menuSize: MenuSize = MenuSize.XL
@@ -76,18 +86,24 @@ class PlayerRatingsGUI(
             index = 50
             itemStack = config.gui.buttons.sort.toItemStack().apply {
                 editMeta {
-                    it.setDisplayName("${translation.sortRating}: ${viewModel.sort.value.desc.toString(translation)}")
+                    it.setDisplayName(
+                        "${translation.sortRating}: ${
+                        playerRatingsComponent.model.value.sort.desc.toString(
+                            translation
+                        )
+                        }"
+                    )
                 }
             }
             click = Click {
-                viewModel.onSortClicked()
+                playerRatingsComponent.onSortClicked()
                 setMenuItems()
             }
         }
     override var maxItemsPerPage: Int = 45
     override var page: Int = 0
     override val maxItemsAmount: Int
-        get() = viewModel.userRatings.value.size
+        get() = playerRatingsComponent.model.value.userRatings.size
 
     override fun onInventoryClicked(e: InventoryClickEvent) {
         e.isCancelled = true
@@ -99,24 +115,24 @@ class PlayerRatingsGUI(
     }
 
     override fun onInventoryClose(it: InventoryCloseEvent) {
-        viewModel.close()
+        playerRatingsComponent.close()
     }
 
     override fun onPageChanged() {
         setMenuItems()
     }
 
     override fun onCreated() {
-        viewModel.userRatings.collectOn(dispatchers.BukkitMain) {
+        playerRatingsComponent.model.collectOn(dispatchers.BukkitMain) {
             setMenuItems()
         }
     }
 
-    private fun setMenuItems() {
+    private fun setMenuItems(model: PlayerRatingsComponent.Model = playerRatingsComponent.model.value) {
         inventory.clear()
         setManageButtons(clickListener)
         sortButton.also(clickListener::remember).setInventoryButton()
-        val list = viewModel.userRatings.value
+        val list = model.userRatings
         for (i in 0 until maxItemsPerPage) {
             val index = maxItemsPerPage * page + i
             if (index >= list.size) {
@@ -126,7 +142,7 @@ class PlayerRatingsGUI(
             val color = if (userAndRating.rating.rating > 0) translation.positiveColor else translation.negativeColor
             InventorySlot.Builder {
                 this.index = i
-                itemStack = RatingsGUIViewModel.getHead(userAndRating.userCreatedReport.normalName).apply {
+                itemStack = PlayerHeadUtil.getHead(userAndRating.userCreatedReport.normalName).apply {
                     editMeta {
                         it.setDisplayName(translation.playerNameColor + userAndRating.userCreatedReport.normalName)
                         it.lore = mutableListOf<String>().apply {
@@ -165,8 +181,8 @@ class PlayerRatingsGUI(
                 click = Click { e ->
                     if (!AstraPermission.DeleteReport.hasPermission(playerHolder.player)) return@Click
                     if (e.click != ClickType.LEFT) return@Click
-                    val item = viewModel.userRatings.value.getOrNull(maxItemsPerPage * page + e.slot) ?: return@Click
-                    viewModel.onDeleteClicked(item)
+                    val item = model.userRatings.getOrNull(maxItemsPerPage * page + e.slot) ?: return@Click
+                    playerRatingsComponent.onDeleteClicked(item)
                 }
             }.also(clickListener::remember).setInventoryButton()
         }