[FIX] Instant in databse, renderers (#43)

## Changes
- Fixed wrong timestamp in Exposed database
- Improved souls renderers

Author: makeevrserg

docker-compose.yml

@@ -0,0 +1,27 @@
+services:
+  # For command call use `docker exec mc_docker_aspekt rcon-cli <your_command>`
+  mc_docker_soulkeeper:
+    restart: no
+    container_name: mc_docker_soulkeeper
+    image: itzg/minecraft-server # https://github.com/itzg/docker-minecraft-server
+    tty: true
+    stdin_open: true
+    ports:
+      - "25565:25565"
+    environment:
+      EULA: true
+      ONLINE_MODE: FALSE
+      # Forge --------------------
+#      TYPE: FORGE
+#      VERSION: "1.20.1"
+#      FORGE_VERSION: "47.2.20"
+      # Paper --------------------
+      TYPE: PAPER
+      VERSION: 1.21.4
+      # Custom -------------------
+    #      CUSTOM_SERVER: https://api.papermc.io/v2/projects/paper/versions/1.21.1/builds/121/downloads/paper-1.21.1-121.jar
+    volumes:
+#      - ./build/forge:/data # Forge
+      - ./build/bukkit:/data # Bukkit/Paper/Spigot
+#      - ./build/velocity:/data # Velocity
+#      - ./build/fabric:/data # Fabric

gradle.properties

@@ -12,7 +12,7 @@ makeevrserg.java.ktarget=21
 # Project
 makeevrserg.project.name=SoulKeeper
 makeevrserg.project.group=ru.astrainteractive.soulkeeper
-makeevrserg.project.version.string=0.2.12
+makeevrserg.project.version.string=0.3.0
 makeevrserg.project.description=Keep your items after death
 makeevrserg.project.developers=makeevrserg|Makeev Roman|makeevrserg@gmail.com
 makeevrserg.project.url=https://github.com/Astra-Interactive/SoulKeeper

instances/bukkit/build.gradle.kts

@@ -34,7 +34,9 @@ dependencies {
     implementation(projects.modules.dao)
     implementation(projects.modules.worker)
 }
-val destination = File("/run/media/makeevrserg/WDGOLD2TB/MinecraftServers/Servers/conf.smp/smp/plugins/")
+val destination = rootDir.resolve("build")
+    .resolve("bukkit")
+    .resolve("plugins")
     .takeIf(File::exists)
     ?: File(rootDir, "jars")
 

instances/bukkit/src/main/kotlin/ru/astrainteractive/soulkeeper/command/SoulsCommandRegistry.kt

@@ -25,13 +25,11 @@ import ru.astrainteractive.soulkeeper.core.plugin.PluginTranslation
 import ru.astrainteractive.soulkeeper.module.souls.dao.SoulsDao
 import ru.astrainteractive.soulkeeper.module.souls.database.model.DatabaseSoul
 import ru.astrainteractive.soulkeeper.module.souls.io.model.Soul
-import ru.astrainteractive.soulkeeper.module.souls.worker.call.SoulCallRenderer
 
 internal class SoulsCommandRegistry(
     private val plugin: JavaPlugin,
     private val scope: CoroutineScope,
     private val soulsDao: SoulsDao,
-    private val soulCallRenderer: SoulCallRenderer,
     translationKrate: Krate<PluginTranslation>,
     kyoriKrate: Krate<KyoriComponentSerializer>
 ) {
@@ -102,8 +100,6 @@ internal class SoulsCommandRegistry(
                         soulsDao.updateSoul(soul.copy(isFree = true))
                             .onSuccess {
                                 audience.sendMessage(translation.souls.soulFreed.component)
-                                soulCallRenderer.removeSoul(soul)
-                                soulCallRenderer.rememberSoul(soul)
                             }
                             .onFailure {
                                 audience.sendMessage(translation.souls.couldNotFreeSoul.component)

instances/bukkit/src/main/kotlin/ru/astrainteractive/soulkeeper/di/RootModule.kt

@@ -29,7 +29,6 @@ interface RootModule {
         private val event = SoulEvents(
             soulsDao = soulsDaoModule.soulsDao,
             soulsConfigKrate = coreModule.soulsConfigKrate,
-            soulCallRenderer = workerModule.soulCallRenderer
         )
 
         private val soulsCommandRegistry = SoulsCommandRegistry(
@@ -38,7 +37,6 @@ interface RootModule {
             soulsDao = soulsDaoModule.soulsDao,
             kyoriKrate = coreModule.kyoriComponentSerializer,
             translationKrate = coreModule.translation,
-            soulCallRenderer = workerModule.soulCallRenderer
         )
 
         private val soulsReloadCommandRegistry = SoulsReloadCommandRegistry(

instances/bukkit/src/main/kotlin/ru/astrainteractive/soulkeeper/event/SoulEvents.kt

@@ -16,12 +16,10 @@ import ru.astrainteractive.soulkeeper.core.util.playSoundForPlayer
 import ru.astrainteractive.soulkeeper.core.util.spawnParticleForPlayer
 import ru.astrainteractive.soulkeeper.module.souls.dao.SoulsDao
 import ru.astrainteractive.soulkeeper.module.souls.io.model.BukkitSoul
-import ru.astrainteractive.soulkeeper.module.souls.worker.call.SoulCallRenderer
 import java.time.Instant
 
 internal class SoulEvents(
     private val soulsDao: SoulsDao,
-    private val soulCallRenderer: SoulCallRenderer,
     soulsConfigKrate: Krate<SoulsConfig>
 ) : EventListener {
     private val scope = CoroutineFeature.Default(Dispatchers.IO)
@@ -77,7 +75,6 @@ internal class SoulEvents(
         bukkitSoul.location.playSoundForPlayer(event.player, soulsConfig.sounds.soulDropped)
         scope.launch {
             soulsDao.insertSoul(bukkitSoul)
-                .onSuccess { soul -> soulCallRenderer.rememberSoul(soul) }
         }
     }
 

modules/core/src/main/kotlin/ru/astrainteractive/soulkeeper/core/util/FlowCombineExt.kt

@@ -0,0 +1,50 @@
+package ru.astrainteractive.soulkeeper.core.util
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.channelFlow
+import kotlinx.coroutines.launch
+
+inline fun <reified T, R> combineInstantly(
+    vararg flows: Flow<T>,
+    crossinline transform: (Array<T?>) -> R
+): Flow<R> {
+    return channelFlow {
+        val array = arrayOfNulls<T>(flows.size)
+        flows.forEachIndexed { index, flow ->
+            launch {
+                flow.collect {
+                    array[index] = it
+                    send(transform.invoke(array))
+                }
+            }
+        }
+    }
+}
+
+inline fun <reified T1, reified T2, R> combineInstantly(
+    flow: Flow<T1>,
+    flow2: Flow<T2>,
+    crossinline transform: (T1?, T2?) -> R,
+): Flow<R> {
+    return combineInstantly(flow, flow2) { array ->
+        transform(
+            array[0] as? T1,
+            array[1] as? T2
+        )
+    }
+}
+
+inline fun <reified T1, reified T2, reified T3, R> combineInstantly(
+    flow: Flow<T1>,
+    flow2: Flow<T2>,
+    flow3: Flow<T3>,
+    crossinline transform: (T1?, T2?, T3?) -> R,
+): Flow<R> {
+    return combineInstantly(flow, flow2, flow3) { array ->
+        transform(
+            array[0] as? T1,
+            array[1] as? T2,
+            array[2] as? T3
+        )
+    }
+}

modules/dao/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/dao/SoulsDao.kt

@@ -1,12 +1,15 @@
 package ru.astrainteractive.soulkeeper.module.souls.dao
 
+import kotlinx.coroutines.flow.Flow
 import org.bukkit.Location
 import ru.astrainteractive.soulkeeper.module.souls.database.model.DatabaseSoul
 import ru.astrainteractive.soulkeeper.module.souls.io.model.BukkitSoul
 import ru.astrainteractive.soulkeeper.module.souls.io.model.Soul
 import java.util.UUID
 
 interface SoulsDao {
+    fun getSoulsChangeFlow(): Flow<Unit>
+
     suspend fun getSouls(): Result<List<DatabaseSoul>>
 
     suspend fun getPlayerSouls(uuid: UUID): Result<List<DatabaseSoul>>

modules/dao/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/dao/SoulsDaoImpl.kt

@@ -1,6 +1,8 @@
 package ru.astrainteractive.soulkeeper.module.souls.dao
 
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
@@ -14,6 +16,7 @@ import org.jetbrains.exposed.sql.and
 import org.jetbrains.exposed.sql.andWhere
 import org.jetbrains.exposed.sql.deleteWhere
 import org.jetbrains.exposed.sql.insertAndGetId
+import org.jetbrains.exposed.sql.or
 import org.jetbrains.exposed.sql.selectAll
 import org.jetbrains.exposed.sql.transactions.transaction
 import org.jetbrains.exposed.sql.update
@@ -26,18 +29,24 @@ import ru.astrainteractive.soulkeeper.module.souls.io.model.BukkitSoul
 import ru.astrainteractive.soulkeeper.module.souls.io.model.Soul
 import java.util.UUID
 
+@Suppress("TooManyFunctions")
 internal class SoulsDaoImpl(
     private val databaseFlow: Flow<Database>,
     private val soulFileEditor: BukkitSoulFile
 ) : SoulsDao, Logger by JUtiltLogger("AspeKt-SoulsDaoImpl") {
     private val mutex = Mutex()
+    private val soulsChangedSharedFlow = MutableSharedFlow<Unit>()
+
+    override fun getSoulsChangeFlow(): Flow<Unit> {
+        return soulsChangedSharedFlow.asSharedFlow()
+    }
 
     private fun toDatabaseSoul(it: ResultRow): DatabaseSoul {
         return DatabaseSoul(
             id = it[SoulTable.id].value,
             ownerUUID = UUID.fromString(it[SoulTable.ownerUUID]),
             ownerLastName = it[SoulTable.ownerLastName],
-            createdAt = it[SoulTable.created_at],
+            createdAt = it[SoulTable.created_at] ?: it[SoulTable.broken_created_at],
             isFree = it[SoulTable.isFree],
             hasXp = it[SoulTable.hasXp],
             hasItems = it[SoulTable.hasItems],
@@ -59,6 +68,7 @@ internal class SoulsDaoImpl(
         mutex.withLock {
             transaction(databaseFlow.first()) {
                 SoulTable.selectAll()
+                    .orderBy(SoulTable.broken_created_at to SortOrder.DESC)
                     .orderBy(SoulTable.created_at to SortOrder.DESC)
                     .map(::toDatabaseSoul)
             }
@@ -82,6 +92,7 @@ internal class SoulsDaoImpl(
                 val id = SoulTable.insertAndGetId {
                     it[SoulTable.ownerUUID] = soul.ownerUUID.toString()
                     it[SoulTable.ownerLastName] = soul.ownerLastName
+                    it[SoulTable.broken_created_at] = soul.createdAt
                     it[SoulTable.created_at] = soul.createdAt
                     it[SoulTable.isFree] = soul.isFree
                     it[SoulTable.locationWorld] = soul.location.world.name
@@ -99,7 +110,7 @@ internal class SoulsDaoImpl(
                     .first()
             }
         }
-    }.logFailure("insertSoul")
+    }.logFailure("insertSoul").onSuccess { soulsChangedSharedFlow.emit(Unit) }
 
     override suspend fun getSoulsNear(location: Location, radius: Int): Result<List<DatabaseSoul>> = runCatching {
         mutex.withLock {
@@ -137,21 +148,26 @@ internal class SoulsDaoImpl(
             soulFileEditor.delete(soul)
             transaction(databaseFlow.first()) {
                 SoulTable.deleteWhere {
-                    SoulTable.created_at.eq(soul.createdAt)
-                        .and(SoulTable.ownerUUID.eq(soul.ownerUUID.toString()))
+                    SoulTable.ownerUUID.eq(soul.ownerUUID.toString()).and {
+                        SoulTable.broken_created_at.eq(soul.createdAt)
+                            .or(SoulTable.created_at.eq(soul.createdAt))
+                    }
                 }
             }
         }
         Unit
-    }.logFailure("deleteSoul")
+    }.logFailure("deleteSoul").onSuccess { soulsChangedSharedFlow.emit(Unit) }
 
     override suspend fun updateSoul(soul: Soul): Result<Unit> = runCatching {
         mutex.withLock {
             transaction(databaseFlow.first()) {
                 SoulTable.update(
                     where = {
-                        SoulTable.created_at.eq(soul.createdAt)
-                            .and(SoulTable.ownerUUID.eq(soul.ownerUUID.toString()))
+                        SoulTable.ownerUUID.eq(soul.ownerUUID.toString())
+                            .and {
+                                SoulTable.broken_created_at.eq(soul.createdAt)
+                                    .or(SoulTable.created_at.eq(soul.createdAt))
+                            }
                     },
                     body = {
                         it[SoulTable.isFree] = soul.isFree
@@ -162,12 +178,12 @@ internal class SoulsDaoImpl(
             }
         }
         Unit
-    }.logFailure("deleteSoul")
+    }.logFailure("deleteSoul").onSuccess { soulsChangedSharedFlow.emit(Unit) }
 
     override suspend fun updateSoul(soul: BukkitSoul): Result<Unit> = runCatching {
         mutex.withLock { soulFileEditor.write(soul).getOrThrow() }
         updateSoul(soul = soul as Soul).getOrThrow()
-    }.logFailure("deleteSoul")
+    }.logFailure("deleteSoul").onSuccess { soulsChangedSharedFlow.emit(Unit) }
 
     override suspend fun toItemStackSoul(soul: Soul): Result<BukkitSoul> {
         return soulFileEditor.read(soul)

modules/dao/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/database/coulmn/KJavaInstantColumnType.kt

@@ -0,0 +1,28 @@
+package ru.astrainteractive.soulkeeper.module.souls.database.coulmn
+
+import org.jetbrains.exposed.sql.ColumnType
+import org.jetbrains.exposed.sql.vendors.currentDialect
+import java.time.Instant
+
+internal class KJavaInstantColumnType : ColumnType<Instant>() {
+    override fun sqlType(): String = currentDialect.dataTypeProvider.longType()
+
+    override fun valueFromDB(value: Any): Instant = when (value) {
+        is Long -> Instant.ofEpochMilli(value)
+        is Number -> Instant.ofEpochMilli(value.toLong())
+        is String -> Instant.ofEpochMilli(value.toLong())
+        else -> error("Unexpected value of type Long: $value of ${value::class.qualifiedName}")
+    }
+
+    override fun valueToDB(value: Instant?): Any? {
+        return value?.toEpochMilli()
+    }
+
+    override fun valueToString(value: Instant?): String {
+        return value?.toEpochMilli()?.toString().orEmpty()
+    }
+
+    override fun nonNullValueToString(value: Instant): String {
+        return value.toEpochMilli().toString()
+    }
+}