0.4.2

0.4.1

cache/admins/common/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/admins/AdminsCacheAPI.kt

@@ -2,7 +2,7 @@ package dev.inmo.tgbotapi.libraries.cache.admins
 
 import dev.inmo.tgbotapi.extensions.utils.asGroupContentMessage
 import dev.inmo.tgbotapi.types.*
-import dev.inmo.tgbotapi.types.ChatMember.abstracts.AdministratorChatMember
+import dev.inmo.tgbotapi.types.chat.member.AdministratorChatMember
 import dev.inmo.tgbotapi.types.message.abstracts.GroupContentMessage
 import dev.inmo.tgbotapi.types.message.abstracts.Message
 

cache/admins/common/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/admins/DefaultAdminsCacheAPI.kt

@@ -5,7 +5,8 @@ import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.chat.get.getChatAdministrators
 import dev.inmo.tgbotapi.types.*
-import dev.inmo.tgbotapi.types.ChatMember.abstracts.AdministratorChatMember
+import dev.inmo.tgbotapi.types.chat.ExtendedBot
+import dev.inmo.tgbotapi.types.chat.member.AdministratorChatMember
 import dev.inmo.tgbotapi.types.message.abstracts.*
 import kotlinx.serialization.Serializable
 

cache/admins/micro_utils/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/admins/micro_utils/DefaultAdminsCacheAPI.kt

@@ -6,7 +6,7 @@ import dev.inmo.micro_utils.coroutines.safelyWithoutExceptions
 import dev.inmo.micro_utils.repos.*
 import dev.inmo.tgbotapi.libraries.cache.admins.DefaultAdminsCacheAPIRepo
 import dev.inmo.tgbotapi.types.*
-import dev.inmo.tgbotapi.types.ChatMember.abstracts.AdministratorChatMember
+import dev.inmo.tgbotapi.types.chat.member.AdministratorChatMember
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.channels.Channel
 import kotlin.coroutines.*

cache/admins/micro_utils/src/jvmMain/kotlin/dev/inmo/tgbotapi/libraries/cache/admins/AdminsCacheAPI.kt

@@ -1,16 +1,14 @@
 package dev.inmo.tgbotapi.libraries.cache.admins
 
 import dev.inmo.micro_utils.repos.exposed.keyvalue.ExposedKeyValueRepo
-import dev.inmo.micro_utils.repos.exposed.onetomany.ExposedOneToManyKeyValueRepo
+import dev.inmo.micro_utils.repos.exposed.onetomany.ExposedKeyValuesRepo
 import dev.inmo.micro_utils.repos.mappers.withMapper
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
 import dev.inmo.tgbotapi.libraries.cache.admins.micro_utils.DefaultAdminsCacheAPIRepo
 import dev.inmo.tgbotapi.libraries.cache.admins.micro_utils.DynamicAdminsCacheSettingsAPI
 import dev.inmo.tgbotapi.types.*
-import dev.inmo.tgbotapi.types.ChatMember.AdministratorChatMemberImpl
-import dev.inmo.tgbotapi.types.ChatMember.CreatorChatMember
-import dev.inmo.tgbotapi.types.ChatMember.abstracts.AdministratorChatMember
+import dev.inmo.tgbotapi.types.chat.member.*
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.serialization.*
 import kotlinx.serialization.cbor.Cbor
@@ -38,7 +36,7 @@ fun AdminsCacheAPI(
 ) : AdminsCacheAPI = DefaultAdminsCacheAPI(
     bot,
     DefaultAdminsCacheAPIRepo(
-        ExposedOneToManyKeyValueRepo(
+        ExposedKeyValuesRepo(
             database,
             { long("chatId") },
             { text("member") },

cache/admins/plagubot/src/jvmMain/kotlin/dev/inmo/tgbotapi/libraries/cache/admins/AdminsPlugin.kt

@@ -8,15 +8,20 @@ import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.Transient
+import kotlinx.serialization.json.JsonObject
 import org.jetbrains.exposed.sql.Database
+import org.koin.core.Koin
+import org.koin.core.module.Module
+import org.koin.core.scope.Scope
 
-val Map<String, Any>.adminsPlugin: AdminsPlugin?
-    get() = get("admins") as? AdminsPlugin
+val Scope.adminsPlugin: AdminsPlugin?
+    get() = getOrNull()
+
+val Koin.adminsPlugin: AdminsPlugin?
+    get() = getOrNull()
 
 @Serializable
-class AdminsPlugin(
-    private val chatsSettings: Map<ChatId, AdminsCacheSettings>? = null
-) : Plugin {
+class AdminsPlugin : Plugin {
     @Transient
     private val globalAdminsCacheAPI = MutableStateFlow<AdminsCacheAPI?>(null)
     @Transient
@@ -24,30 +29,24 @@ class AdminsPlugin(
     private val mutex = Mutex()
 
     suspend fun adminsAPI(database: Database): AdminsCacheAPI {
-        return when (chatsSettings) {
-            null -> {
         val flow = mutex.withLock {
             databaseToAdminsCacheAPI.getOrPut(database){ MutableStateFlow(null) }
         }
-                flow.first { it != null }!!
-            }
-            else -> globalAdminsCacheAPI.first { it != null }!!
-        }
+        return flow.filterNotNull().first()
     }
 
-    override suspend fun BehaviourContext.invoke(database: Database, params: Map<String, Any>) {
-        when (chatsSettings) {
-            null -> {
+    override fun Module.setupDI(database: Database, params: JsonObject) {
+        single { this@AdminsPlugin }
+    }
+
+    override suspend fun BehaviourContext.setupBotPlugin(koin: Koin) {
+        with(koin) {
             mutex.withLock {
-                    val flow = databaseToAdminsCacheAPI.getOrPut(database){ MutableStateFlow(null) }
+                val flow = databaseToAdminsCacheAPI.getOrPut(koin.get()){ MutableStateFlow(null) }
                 if (flow.value == null) {
-                        flow.value = AdminsCacheAPI(database)
+                    flow.value = AdminsCacheAPI(koin.get())
                 }
             }
         }
-            else -> mutex.withLock {
-                globalAdminsCacheAPI.value = AdminsCacheAPI(database)
-            }
-        }
     }
 }

cache/content/common/build.gradle

@@ -6,3 +6,13 @@ plugins {
 
 apply from: "$mppProjectWithSerializationPresetPath"
 
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api "dev.inmo:tgbotapi.core:$tgbotapi_version"
+            }
+        }
+    }
+}
+

cache/content/common/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/media/common/DefaultMessageContentCache.kt

@@ -0,0 +1,122 @@
+package dev.inmo.tgbotapi.libraries.cache.media.common
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.DownloadFileStream
+import dev.inmo.tgbotapi.requests.get.GetFile
+import dev.inmo.tgbotapi.requests.send.media.*
+import dev.inmo.tgbotapi.types.ChatId
+import dev.inmo.tgbotapi.types.media.*
+import dev.inmo.tgbotapi.types.message.content.MediaContent
+import dev.inmo.tgbotapi.types.message.content.MessageContent
+import dev.inmo.tgbotapi.utils.asInput
+import io.ktor.utils.io.core.Input
+
+class DefaultMessageContentCache<K>(
+    private val bot: TelegramBot,
+    private val filesRefreshingChatId: ChatId,
+    private val simpleMessageContentCache: MessagesSimpleCache<K>,
+    private val mediaFileActualityChecker: MediaFileActualityChecker = MediaFileActualityChecker.WithDelay(
+        MediaFileActualityChecker.Default(filesRefreshingChatId)
+    ),
+    private val messagesFilesCache: MessagesFilesCache<K> = InMemoryMessagesFilesCache()
+) : MessageContentCache<K> {
+    override suspend fun save(k: K, content: MessageContent) {
+        when (content) {
+            is MediaContent -> {
+                val extendedInfo = bot.execute(
+                    GetFile(content.media.fileId)
+                )
+                val allocator = bot.execute(
+                    DownloadFileStream(
+                        extendedInfo.filePath
+                    )
+                )
+
+                save(k, content, extendedInfo.fileName) {
+                    allocator.invoke().asInput()
+                }
+            }
+            else -> simpleMessageContentCache.set(k, content)
+        }
+    }
+
+    override suspend fun save(
+        k: K,
+        content: MediaContent,
+        filename: String,
+        inputAllocator: suspend () -> Input
+    ) {
+        simpleMessageContentCache.set(k, content)
+        runCatching {
+            messagesFilesCache.set(k, filename, inputAllocator)
+        }.onFailure {
+            simpleMessageContentCache.remove(k)
+        }.onSuccess {
+            with(mediaFileActualityChecker) {
+                bot.saved(content)
+            }
+        }
+    }
+
+    override suspend fun get(k: K): MessageContent? {
+        val savedSimpleContent = simpleMessageContentCache.get(k) ?: return null
+
+        if (savedSimpleContent is MediaContent && !with(mediaFileActualityChecker) { bot.isActual(savedSimpleContent) }) {
+            val savedFileContentAllocator = messagesFilesCache.get(k) ?: error("Unexpected absence of $k file for content ($simpleMessageContentCache)")
+            val newContent = bot.execute(
+                when (savedSimpleContent.asTelegramMedia()) {
+                    is TelegramMediaAnimation -> SendAnimation(
+                        filesRefreshingChatId,
+                        savedFileContentAllocator,
+                        disableNotification = true
+                    )
+                    is TelegramMediaAudio -> SendAudio(
+                        filesRefreshingChatId,
+                        savedFileContentAllocator,
+                        disableNotification = true
+                    )
+                    is TelegramMediaVideo -> SendVideo(
+                        filesRefreshingChatId,
+                        savedFileContentAllocator,
+                        disableNotification = true
+                    )
+                    is TelegramMediaDocument -> SendDocument(
+                        filesRefreshingChatId,
+                        savedFileContentAllocator,
+                        disableNotification = true
+                    )
+                    is TelegramMediaPhoto -> SendPhoto(
+                        filesRefreshingChatId,
+                        savedFileContentAllocator,
+                        disableNotification = true
+                    )
+                }
+            )
+
+            simpleMessageContentCache.update(k, newContent.content)
+            return newContent.content
+        }
+        return savedSimpleContent
+    }
+
+    override suspend fun contains(k: K): Boolean {
+        return simpleMessageContentCache.contains(k)
+    }
+
+    override suspend fun remove(k: K) {
+        simpleMessageContentCache.remove(k)
+        messagesFilesCache.remove(k)
+    }
+
+    companion object {
+        operator fun invoke(
+            bot: TelegramBot,
+            filesRefreshingChatId: ChatId,
+            simpleMessageContentCache: MessagesSimpleCache<String> = InMemoryMessagesSimpleCache(),
+            mediaFileActualityChecker: MediaFileActualityChecker = MediaFileActualityChecker.WithDelay(
+                MediaFileActualityChecker.Default(filesRefreshingChatId)
+            ),
+            messagesFilesCache: MessagesFilesCache<String> = InMemoryMessagesFilesCache()
+        ) = DefaultMessageContentCache(bot, filesRefreshingChatId, simpleMessageContentCache, mediaFileActualityChecker, messagesFilesCache)
+    }
+}

cache/content/common/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/media/common/MediaFileActualityChecker.kt

@@ -0,0 +1,55 @@
+package dev.inmo.tgbotapi.libraries.cache.media.common
+
+import com.soywiz.klock.DateTime
+import com.soywiz.klock.milliseconds
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.DeleteMessage
+import dev.inmo.tgbotapi.requests.abstracts.FileId
+import dev.inmo.tgbotapi.types.ChatId
+import dev.inmo.tgbotapi.types.MilliSeconds
+import dev.inmo.tgbotapi.types.message.content.MediaContent
+
+fun interface MediaFileActualityChecker {
+    suspend fun TelegramBot.isActual(mediaContent: MediaContent): Boolean
+    suspend fun TelegramBot.saved(mediaContent: MediaContent) {}
+
+    class Default(
+        private val checkingChatId: ChatId
+    ) : MediaFileActualityChecker {
+        override suspend fun TelegramBot.isActual(mediaContent: MediaContent): Boolean {
+            return runCatching {
+                execute(mediaContent.createResend(checkingChatId)).also { sentMessage ->
+                    execute(DeleteMessage(sentMessage.chat.id, sentMessage.messageId))
+                }
+            }.isSuccess
+        }
+    }
+
+    class WithDelay(
+        private val underhoodChecker: MediaFileActualityChecker,
+        private val checkingDelay: MilliSeconds = 24 * 60 * 60 * 1000L // one day
+    ) : MediaFileActualityChecker {
+        private val fileIdChecksMap = mutableMapOf<FileId, DateTime>()
+        private val checkingDelayTimeSpan = checkingDelay.milliseconds
+
+        override suspend fun TelegramBot.isActual(mediaContent: MediaContent): Boolean {
+            val now = DateTime.now()
+            val lastCheck = fileIdChecksMap[mediaContent.media.fileId]
+            return if (lastCheck == null || now - lastCheck > checkingDelayTimeSpan) {
+                with(underhoodChecker) {
+                    isActual(mediaContent)
+                }.also {
+                    if (it) {
+                        fileIdChecksMap[mediaContent.media.fileId] = now
+                    }
+                }
+            } else {
+                true
+            }
+        }
+
+        override suspend fun TelegramBot.saved(mediaContent: MediaContent) {
+            fileIdChecksMap[mediaContent.media.fileId] = DateTime.now()
+        }
+    }
+}

cache/content/common/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/media/common/MessageContentCache.kt

@@ -0,0 +1,19 @@
+package dev.inmo.tgbotapi.libraries.cache.media.common
+
+import dev.inmo.tgbotapi.types.message.content.MediaContent
+import dev.inmo.tgbotapi.types.message.content.MessageContent
+import io.ktor.utils.io.core.Input
+
+interface MessageContentCache<K> {
+    suspend fun save(k: K, content: MessageContent)
+    suspend fun save(
+        k: K,
+        content: MediaContent,
+        filename: String,
+        inputAllocator: suspend () -> Input
+    )
+
+    suspend fun get(k: K): MessageContent?
+    suspend fun contains(k: K): Boolean
+    suspend fun remove(k: K)
+}

cache/content/common/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/media/common/MessagesFilesCache.kt

@@ -0,0 +1,41 @@
+package dev.inmo.tgbotapi.libraries.cache.media.common
+
+import dev.inmo.tgbotapi.requests.abstracts.MultipartFile
+import io.ktor.utils.io.core.*
+
+interface MessagesFilesCache<K> {
+    suspend fun set(k: K, filename: String, inputAllocator: suspend () -> Input)
+    suspend fun get(k: K): MultipartFile?
+    suspend fun remove(k: K)
+    suspend fun contains(k: K): Boolean
+}
+
+/**
+ * It is not recommended to use in production realization of [MessagesFilesCache] which has been created for fast
+ * start of application creation with usage of [MessageContentCache] with aim to replace this realization by some
+ * disks-oriented one
+ */
+class InMemoryMessagesFilesCache<K> : MessagesFilesCache<K> {
+    private val map = mutableMapOf<K, MultipartFile>()
+
+    override suspend fun set(k: K, filename: String, inputAllocator: suspend () -> Input) {
+        val input = inputAllocator()
+        map[k] = MultipartFile(
+            filename
+        ) {
+            input
+        }
+    }
+
+    override suspend fun get(k: K): MultipartFile? {
+        return map[k]
+    }
+
+    override suspend fun remove(k: K) {
+        map.remove(k)
+    }
+
+    override suspend fun contains(k: K): Boolean {
+        return map.contains(k)
+    }
+}

cache/content/common/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/media/common/MessagesSimpleCache.kt

@@ -0,0 +1,53 @@
+package dev.inmo.tgbotapi.libraries.cache.media.common
+
+import dev.inmo.tgbotapi.types.message.content.MessageContent
+
+interface MessagesSimpleCache<K> {
+    suspend fun set(k: K, content: MessageContent)
+    suspend fun update(k: K, content: MessageContent): Boolean
+    suspend fun get(k: K): MessageContent?
+    suspend fun remove(k: K)
+    suspend fun contains(k: K): Boolean
+}
+
+/**
+ * It is not recommended to use in production realization of [MessagesFilesCache] which has been created for fast
+ * start of application creation with usage of [MessageContentCache] with aim to replace this realization by some
+ * disks-oriented one
+ */
+class InMemoryMessagesSimpleCache<K> : MessagesSimpleCache<K> {
+    private val map = mutableMapOf<K, MessageContent>()
+
+    override suspend fun set(
+        k: K,
+        content: MessageContent
+    ) {
+        map[k] = content
+    }
+
+    override suspend fun update(
+        k: K,
+        content: MessageContent
+    ): Boolean {
+        return map.runCatching {
+            if (contains(k)) {
+                put(k, content)
+                true
+            } else {
+                false
+            }
+        }.getOrDefault(false)
+    }
+
+    override suspend fun get(k: K): MessageContent? {
+        return map[k]
+    }
+
+    override suspend fun remove(k: K) {
+        map.remove(k)
+    }
+
+    override suspend fun contains(k: K): Boolean {
+        return map.contains(k)
+    }
+}

cache/content/common/src/jvmMain/kotlin/dev/inmo/tgbotapi/libraries/cache/media/common/InFilesMessagesFilesCache.kt

@@ -0,0 +1,72 @@
+package dev.inmo.tgbotapi.libraries.cache.media.common
+
+import dev.inmo.tgbotapi.requests.abstracts.MultipartFile
+import io.ktor.utils.io.core.Input
+import io.ktor.utils.io.core.copyTo
+import io.ktor.utils.io.streams.asInput
+import io.ktor.utils.io.streams.asOutput
+import java.io.File
+
+class InFilesMessagesFilesCache<K>(
+    private val folderFile: File,
+    private val filePrefixBuilder: (K) -> String
+) : MessagesFilesCache<K> {
+    private val K.multipartFile: MultipartFile?
+        get() {
+            val prefix = filePrefix(this)
+            val filename = folderFile.list() ?.firstOrNull { it.startsWith(prefix) } ?: return null
+            val file = File(folderFile, filename)
+            val storageFileFilename = file.name.removePrefix("$prefix ")
+
+            return MultipartFile(storageFileFilename) {
+                file.inputStream().asInput()
+            }
+        }
+
+    init {
+        require(!folderFile.isFile) { "Folder of messages files cache can't be file, but was $folderFile" }
+        folderFile.mkdirs()
+    }
+
+    private fun filePrefix(k: K): String = filePrefixBuilder(k)
+
+    private fun fileName(k: K, filename: String): String {
+        return "${filePrefix(k)} $filename"
+    }
+
+    override suspend fun set(k: K, filename: String, inputAllocator: suspend () -> Input) {
+        val fullFileName = fileName(k, filename)
+        val file = File(folderFile, fullFileName).apply {
+            delete()
+        }
+        inputAllocator().use { input ->
+            file.outputStream().asOutput().use { output ->
+                input.copyTo(output)
+            }
+        }
+    }
+
+    override suspend fun get(k: K): MultipartFile? {
+        return k.multipartFile
+    }
+
+    override suspend fun remove(k: K) {
+        val prefix = filePrefix(k)
+        folderFile.listFiles() ?.forEach {
+            if (it.name.startsWith(prefix)) {
+                it.delete()
+            }
+        }
+    }
+
+    override suspend fun contains(k: K): Boolean {
+        val prefix = filePrefix(k)
+        return folderFile.list() ?.any { it.startsWith(prefix) } == true
+    }
+
+    companion object {
+        operator fun invoke(folderFile: File) = InFilesMessagesFilesCache<String>(
+            folderFile
+        ) { it }
+    }
+}

cache/content/common/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="dev.inmo.tgbotapi.libraries.cache.content.common"/>

cache/content/micro_utils/build.gradle

@@ -0,0 +1,19 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
+}
+
+apply from: "$mppProjectWithSerializationPresetPath"
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api "dev.inmo:micro_utils.repos.common:$micro_utils_version"
+                api project(":tgbotapi.libraries.cache.content.common")
+            }
+        }
+    }
+}
+

cache/content/micro_utils/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/media/micro_utils/SimpleKeyValueMessageContentCache.kt

@@ -0,0 +1,95 @@
+package dev.inmo.tgbotapi.libraries.cache.media.micro_utils
+
+import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.mappers.withMapper
+import dev.inmo.tgbotapi.libraries.cache.media.common.MessagesSimpleCache
+import dev.inmo.tgbotapi.types.ChatId
+import dev.inmo.tgbotapi.types.MessageIdentifier
+import dev.inmo.tgbotapi.types.message.content.MessageContent
+import kotlinx.serialization.*
+import kotlinx.serialization.builtins.PairSerializer
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.modules.SerializersModule
+import kotlin.js.JsName
+import kotlin.jvm.JvmName
+
+class SimpleKeyValueMessageContentCache<K>(
+    private val keyValueRepo: KeyValueRepo<K, MessageContent>
+) : MessagesSimpleCache<K> {
+    override suspend fun set(k: K, content: MessageContent) {
+        keyValueRepo.set(k, content)
+    }
+
+    override suspend fun update(k: K, content: MessageContent): Boolean {
+        return keyValueRepo.runCatching {
+            if (contains(k)) {
+                keyValueRepo.set(k, content)
+                true
+            } else {
+                false
+            }
+        }.getOrDefault(false)
+    }
+
+    override suspend fun get(k: K): MessageContent? {
+        return keyValueRepo.get(k)
+    }
+
+    override suspend fun contains(k: K): Boolean {
+        return keyValueRepo.contains(k)
+    }
+
+    override suspend fun remove(k: K) {
+        keyValueRepo.unset(k)
+    }
+}
+
+val chatIdToMessageIdentifierSerializer = PairSerializer(
+    ChatId.serializer(),
+    MessageIdentifier.serializer()
+)
+
+val messageContentSerializer = PolymorphicSerializer<MessageContent>(MessageContent::class)
+
+inline fun <K> KeyValueRepo<K, MessageContent>.asMessageContentCache() = SimpleKeyValueMessageContentCache(this)
+
+inline fun KeyValueRepo<String, String>.asMessageContentCache(
+    serialFormatCreator: (SerializersModule) -> StringFormat = { Json { serializersModule = it } }
+): StandardKeyValueRepo<Pair<ChatId, MessageIdentifier>, MessageContent> {
+    val serialFormat = serialFormatCreator(MessageContent.serializationModule())
+    return withMapper<Pair<ChatId, MessageIdentifier>, MessageContent, String, String>(
+        { serialFormat.encodeToString(chatIdToMessageIdentifierSerializer, this) },
+        { serialFormat.encodeToString(messageContentSerializer, this) },
+        { serialFormat.decodeFromString(chatIdToMessageIdentifierSerializer, this) },
+        { serialFormat.decodeFromString(messageContentSerializer, this) },
+    )
+}
+
+@JvmName("stringsKeyValueAsHexMessageContentCache")
+@JsName("stringsKeyValueAsHexMessageContentCache")
+inline fun KeyValueRepo<String, String>.asMessageContentCache(
+    serialFormatCreator: (SerializersModule) -> BinaryFormat
+): StandardKeyValueRepo<Pair<ChatId, MessageIdentifier>, MessageContent> {
+    val serialFormat = serialFormatCreator(MessageContent.serializationModule())
+    return withMapper<Pair<ChatId, MessageIdentifier>, MessageContent, String, String>(
+        { serialFormat.encodeToHexString(chatIdToMessageIdentifierSerializer, this) },
+        { serialFormat.encodeToHexString(messageContentSerializer, this) },
+        { serialFormat.decodeFromHexString(chatIdToMessageIdentifierSerializer, this) },
+        { serialFormat.decodeFromHexString(messageContentSerializer, this) },
+    )
+}
+
+@JvmName("bytesKeyValueAsMessageContentCache")
+@JsName("bytesKeyValueAsMessageContentCache")
+inline fun KeyValueRepo<ByteArray, ByteArray>.asMessageContentCache(
+    serialFormatCreator: (SerializersModule) -> BinaryFormat
+): StandardKeyValueRepo<Pair<ChatId, MessageIdentifier>, MessageContent> {
+    val serialFormat = serialFormatCreator(MessageContent.serializationModule())
+    return withMapper<Pair<ChatId, MessageIdentifier>, MessageContent, ByteArray, ByteArray>(
+        { serialFormat.encodeToByteArray(chatIdToMessageIdentifierSerializer, this) },
+        { serialFormat.encodeToByteArray(messageContentSerializer, this) },
+        { serialFormat.decodeFromByteArray(chatIdToMessageIdentifierSerializer, this) },
+        { serialFormat.decodeFromByteArray(messageContentSerializer, this) },
+    )
+}

cache/content/micro_utils/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="dev.inmo.tgbotapi.libraries.cache.content.micro_utils"/>

cache/media/src/main/AndroidManifest.xml

@@ -1 +0,0 @@
-<manifest package="dev.inmo.tgbotapi.libraries.cache.media"/>

gradle.properties

@@ -6,32 +6,32 @@ kotlin.incremental.js=true
 android.useAndroidX=true
 android.enableJetifier=true
 
-kotlin_version=1.6.10
-kotlin_serialisation_core_version=1.3.2
+kotlin_version=1.6.21
+kotlin_serialisation_core_version=1.3.3
 
-github_release_plugin_version=2.2.12
+github_release_plugin_version=2.4.1
 
-tgbotapi_version=0.38.4
-micro_utils_version=0.9.5
-exposed_version=0.37.2
-plagubot_version=0.5.1
+tgbotapi_version=2.2.2
+micro_utils_version=0.11.13
+exposed_version=0.38.2
+plagubot_version=1.4.1
 
 # ANDROID
 
 android_minSdkVersion=21
 android_compileSdkVersion=32
 android_buildToolsVersion=32.0.0
-dexcount_version=3.0.1
+dexcount_version=3.1.0
 junit_version=4.12
 test_ext_junit_version=1.1.2
 espresso_core=3.3.0
 
 # Dokka
 
-dokka_version=1.6.10
+dokka_version=1.6.21
 
 # Project data
 
 group=dev.inmo
-version=0.0.16
-android_code_version=16
+version=0.4.2
+android_code_version=26

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

mppJavaProject.gradle

@@ -5,7 +5,11 @@ apply from: "$publishGradlePath"
 
 kotlin {
     jvm {
-        compilations.main.kotlinOptions.useIR = true
+        compilations.main {
+            kotlinOptions {
+                jvmTarget = "1.8"
+            }
+        }
     }
 
     sourceSets {

mppProjectWithSerialization.gradle

@@ -4,7 +4,13 @@ project.group = "$group"
 apply from: "$publishGradlePath"
 
 kotlin {
-    jvm()
+    jvm {
+        compilations.main {
+            kotlinOptions {
+                jvmTarget = "1.8"
+            }
+        }
+    }
     js (IR) {
         browser()
         nodejs()

settings.gradle

@@ -4,13 +4,15 @@ String[] includes = [
     ":cache:admins:common",
     ":cache:admins:micro_utils",
     ":cache:admins:plagubot",
-    ":cache:media"
+
+    ":cache:content:common",
+    ":cache:content:micro_utils",
 ]
 
 
 includes.each { originalName ->
-    String projectDirectory = "${rootProject.projectDir.getAbsolutePath()}${originalName.replaceAll(":", File.separator)}"
-    String projectName = "${rootProject.name}${originalName.replaceAll(":", ".")}"
+    String projectDirectory = "${rootProject.projectDir.getAbsolutePath()}${originalName.replace(":", File.separator)}"
+    String projectName = "${rootProject.name}${originalName.replace(":", ".")}"
     String projectIdentifier = ":${projectName}"
     include projectIdentifier
     ProjectDescriptor project = project(projectIdentifier)