update dependencies

0.26.2

.gitignore

@@ -1,4 +1,5 @@
 .idea
+.kotlin
 out/*
 *.iml
 target

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

@@ -38,8 +38,8 @@ fun TelegramBot.createAdminsCacheAPI(
             { long("chatId") },
             { text("member") },
             "AdminsTable"
-        ).withMapper<IdChatIdentifier, AdministratorChatMember, Identifier, String>(
+        ).withMapper<IdChatIdentifier, AdministratorChatMember, Long, String>(
-            keyFromToTo = { chatId },
+            keyFromToTo = { chatId.long },
             valueFromToTo = { telegramAdminsSerializationFormat.encodeToString(AdministratorChatMember.serializer(), this) },
             keyToToFrom = { toChatId() },
             valueToToFrom = { telegramAdminsSerializationFormat.decodeFromString(AdministratorChatMember.serializer(), this) }
@@ -49,8 +49,8 @@ fun TelegramBot.createAdminsCacheAPI(
             { long("chatId") },
             { long("datetime") },
             "AdminsUpdatesTimesTable"
-        ).withMapper<IdChatIdentifier, Long, Identifier, Long>(
+        ).withMapper<IdChatIdentifier, Long, Long, Long>(
-            keyFromToTo = { chatId },
+            keyFromToTo = { chatId.long },
             valueFromToTo = { this },
             keyToToFrom = { toChatId() },
             valueToToFrom = { this }
@@ -63,8 +63,8 @@ fun TelegramBot.createAdminsCacheAPI(
             { long("chatId") },
             { text("settings") },
             "DynamicAdminsCacheSettingsAPI"
-        ).withMapper<IdChatIdentifier, AdminsCacheSettings, Identifier, String>(
+        ).withMapper<IdChatIdentifier, AdminsCacheSettings, Long, String>(
-            keyFromToTo = { chatId },
+            keyFromToTo = { chatId.long },
             valueFromToTo = { telegramAdminsSerializationFormat.encodeToString(AdminsCacheSettings.serializer() , this) },
             keyToToFrom = { toChatId() },
             valueToToFrom = { telegramAdminsSerializationFormat.decodeFromString(AdminsCacheSettings.serializer() , this) }

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

@@ -4,6 +4,7 @@ import dev.inmo.micro_utils.repos.exposed.keyvalue.ExposedKeyValueRepo
 import dev.inmo.micro_utils.repos.exposed.onetomany.ExposedKeyValuesRepo
 import dev.inmo.micro_utils.repos.mappers.withMapper
 import dev.inmo.plagubot.Plugin
+import dev.inmo.plagubot.database
 import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
 import dev.inmo.tgbotapi.libraries.cache.admins.micro_utils.DefaultAdminsCacheAPIRepoImpl
 import dev.inmo.tgbotapi.libraries.cache.admins.micro_utils.DynamicAdminsCacheSettingsAPI
@@ -44,7 +45,7 @@ class AdminsPlugin : Plugin {
         return flow.filterNotNull().first()
     }
 
-    override fun Module.setupDI(database: Database, params: JsonObject) {
+    override fun Module.setupDI(config: JsonObject) {
         single { this@AdminsPlugin }
         val scopeQualifier = named("admins plugin scope")
         single(scopeQualifier) { CoroutineScope(Dispatchers.IO + SupervisorJob()) }
@@ -55,8 +56,8 @@ class AdminsPlugin : Plugin {
                     { long("chatId") },
                     { text("member") },
                     "AdminsTable"
-                ).withMapper<IdChatIdentifier, AdministratorChatMember, Identifier, String>(
+                ).withMapper<IdChatIdentifier, AdministratorChatMember, Long, String>(
-                    keyFromToTo = { chatId },
+                    keyFromToTo = { chatId.long },
                     valueFromToTo = { telegramAdminsSerializationFormat.encodeToString(this) },
                     keyToToFrom = { toChatId() },
                     valueToToFrom = { telegramAdminsSerializationFormat.decodeFromString(this) }
@@ -66,8 +67,8 @@ class AdminsPlugin : Plugin {
                     { long("chatId") },
                     { long("datetime") },
                     "AdminsUpdatesTimesTable"
-                ).withMapper<IdChatIdentifier, Long, Identifier, Long>(
+                ).withMapper<IdChatIdentifier, Long, Long, Long>(
-                    keyFromToTo = { chatId },
+                    keyFromToTo = { chatId.long },
                     valueFromToTo = { this },
                     keyToToFrom = { toChatId() },
                     valueToToFrom = { this }
@@ -82,8 +83,8 @@ class AdminsPlugin : Plugin {
                     { long("chatId") },
                     { text("settings") },
                     "DynamicAdminsCacheSettingsAPI"
-                ).withMapper<IdChatIdentifier, AdminsCacheSettings, Identifier, String>(
+                ).withMapper<IdChatIdentifier, AdminsCacheSettings, Long, String>(
-                    keyFromToTo = { chatId },
+                    keyFromToTo = { chatId.long },
                     valueFromToTo = { telegramAdminsSerializationFormat.encodeToString(this) },
                     keyToToFrom = { toChatId() },
                     valueToToFrom = { telegramAdminsSerializationFormat.decodeFromString(this) }

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

@@ -3,8 +3,7 @@ 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.*
-import io.ktor.utils.io.streams.asOutput
 import java.io.File
 
 class InFilesMessagesFilesCache<K>(
@@ -39,8 +38,8 @@ class InFilesMessagesFilesCache<K>(
         val file = File(folderFile, fullFileName).apply {
             delete()
         }
-        inputAllocator().use { input ->
+        inputAllocator().inputStream().use { input ->
-            file.outputStream().asOutput().use { output ->
+            file.outputStream().use { output ->
                 input.copyTo(output)
             }
         }

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

@@ -4,7 +4,7 @@ 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.MessageId
 import dev.inmo.tgbotapi.types.message.content.MessageContent
 import kotlinx.serialization.*
 import kotlinx.serialization.builtins.PairSerializer
@@ -47,7 +47,7 @@ class SimpleKeyValueMessageContentCache<K>(
 
 val chatIdToMessageIdentifierSerializer = PairSerializer(
     ChatId.serializer(),
-    MessageIdentifier.serializer()
+    MessageId.serializer()
 )
 
 val messageContentSerializer = PolymorphicSerializer<MessageContent>(MessageContent::class)
@@ -56,9 +56,9 @@ inline fun <K> KeyValueRepo<K, MessageContent>.asMessageContentCache() = SimpleK
 
 inline fun KeyValueRepo<String, String>.asMessageContentCache(
     serialFormatCreator: (SerializersModule) -> StringFormat = { Json { serializersModule = it } }
-): StandardKeyValueRepo<Pair<ChatId, MessageIdentifier>, MessageContent> {
+): StandardKeyValueRepo<Pair<ChatId, MessageId>, MessageContent> {
     val serialFormat = serialFormatCreator(MessageContent.serializationModule())
-    return withMapper<Pair<ChatId, MessageIdentifier>, MessageContent, String, String>(
+    return withMapper<Pair<ChatId, MessageId>, MessageContent, String, String>(
         { serialFormat.encodeToString(chatIdToMessageIdentifierSerializer, this) },
         { serialFormat.encodeToString(messageContentSerializer, this) },
         { serialFormat.decodeFromString(chatIdToMessageIdentifierSerializer, this) },
@@ -70,9 +70,9 @@ inline fun KeyValueRepo<String, String>.asMessageContentCache(
 @JsName("stringsKeyValueAsHexMessageContentCache")
 inline fun KeyValueRepo<String, String>.asMessageContentCache(
     serialFormatCreator: (SerializersModule) -> BinaryFormat
-): StandardKeyValueRepo<Pair<ChatId, MessageIdentifier>, MessageContent> {
+): StandardKeyValueRepo<Pair<ChatId, MessageId>, MessageContent> {
     val serialFormat = serialFormatCreator(MessageContent.serializationModule())
-    return withMapper<Pair<ChatId, MessageIdentifier>, MessageContent, String, String>(
+    return withMapper<Pair<ChatId, MessageId>, MessageContent, String, String>(
         { serialFormat.encodeToHexString(chatIdToMessageIdentifierSerializer, this) },
         { serialFormat.encodeToHexString(messageContentSerializer, this) },
         { serialFormat.decodeFromHexString(chatIdToMessageIdentifierSerializer, this) },
@@ -84,9 +84,9 @@ inline fun KeyValueRepo<String, String>.asMessageContentCache(
 @JsName("bytesKeyValueAsMessageContentCache")
 inline fun KeyValueRepo<ByteArray, ByteArray>.asMessageContentCache(
     serialFormatCreator: (SerializersModule) -> BinaryFormat
-): StandardKeyValueRepo<Pair<ChatId, MessageIdentifier>, MessageContent> {
+): StandardKeyValueRepo<Pair<ChatId, MessageId>, MessageContent> {
     val serialFormat = serialFormatCreator(MessageContent.serializationModule())
-    return withMapper<Pair<ChatId, MessageIdentifier>, MessageContent, ByteArray, ByteArray>(
+    return withMapper<Pair<ChatId, MessageId>, MessageContent, ByteArray, ByteArray>(
         { serialFormat.encodeToByteArray(chatIdToMessageIdentifierSerializer, this) },
         { serialFormat.encodeToByteArray(messageContentSerializer, this) },
         { serialFormat.decodeFromByteArray(chatIdToMessageIdentifierSerializer, this) },

gradle.properties

@@ -6,21 +6,21 @@ kotlin.incremental=true
 kotlin.incremental.js=true
 
 
-kotlin_version=1.9.22
+kotlin_version=2.1.10
-kotlin_serialisation_core_version=1.6.2
+kotlin_serialisation_core_version=1.8.0
 
-github_release_plugin_version=2.4.1
+github_release_plugin_version=2.5.2
 
-tgbotapi_version=10.0.1
+tgbotapi_version=23.2.0
-micro_utils_version=0.20.32
+micro_utils_version=0.24.6
-exposed_version=0.47.0
+exposed_version=0.59.0
-plagubot_version=8.1.1
+plagubot_version=10.4.0
 
 # Dokka
 
-dokka_version=1.9.10
+dokka_version=2.0.0
 
 # Project data
 
 group=dev.inmo
-version=0.18.1
+version=0.26.3

gradle/wrapper/gradle-wrapper.properties

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

mppJavaWithJsProject.gradle

@@ -37,7 +37,6 @@ kotlin {
         jsTest {
             dependencies {
                 implementation kotlin('test-js')
-                implementation kotlin('test-junit')
             }
         }
     }

renovate.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended"
+  ]
+}

resender/src/commonMain/kotlin/MessageMetaInfo.kt

@@ -2,6 +2,7 @@ package dev.inmo.tgbotapi.libraries.resender
 
 import dev.inmo.tgbotapi.types.FullChatIdentifierSerializer
 import dev.inmo.tgbotapi.types.IdChatIdentifier
+import dev.inmo.tgbotapi.types.MediaGroupId
 import dev.inmo.tgbotapi.types.MessageId
 import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
 import dev.inmo.tgbotapi.types.message.abstracts.Message
@@ -14,7 +15,7 @@ data class MessageMetaInfo(
     @Serializable(FullChatIdentifierSerializer::class)
     val chatId: IdChatIdentifier,
     val messageId: MessageId,
-    val group: String? = null
+    val group: MediaGroupId? = null
 ) {
     val metaInfo: Message.MetaInfo
         get() = Message.MetaInfo(chatId, messageId)

resender/src/commonMain/kotlin/MessagesResender.kt

@@ -3,6 +3,7 @@ package dev.inmo.tgbotapi.libraries.resender
 import dev.inmo.micro_utils.common.applyDiff
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.ForwardMessage
+import dev.inmo.tgbotapi.requests.ForwardMessages
 import dev.inmo.tgbotapi.requests.send.CopyMessage
 import dev.inmo.tgbotapi.requests.send.CopyMessages
 import dev.inmo.tgbotapi.requests.send.media.SendMediaGroup
@@ -21,58 +22,135 @@ class MessagesResender(
         messagesInfo: List<MessageMetaInfo>,
         onBetweenMessages: suspend (sent: List<MessageMetaInfo>, toBeSent: List<MessageMetaInfo>) -> Unit
     ): List<Pair<MessageMetaInfo, MessageMetaInfo>> {
-        val currentGroup = mutableListOf<MessageMetaInfo>()
+        val messagesWithOrders = messagesInfo.mapIndexed { i, messageInfo -> messageInfo to i }.toMap()
-        suspend fun makeCopy(): List<Pair<MessageMetaInfo, MessageMetaInfo>> {
+        val ordersWithMessagesGroups = messagesInfo.groupBy { it.group }.flatMap { (group, list) ->
-            currentGroup.sortBy { it.messageId }
+            if (group == null) {
-            while (currentGroup.isNotEmpty()) {
+                list.map {
-                return runCatching {
+                    messagesWithOrders.getValue(it) to listOf(it)
-                    bot.execute(
+                }
-                        CopyMessages(
+            } else {
-                            toChatId = targetChatId,
+                listOf(messagesWithOrders.getValue(list.first()) to list)
-                            fromChatId = currentGroup.firstOrNull() ?.chatId ?: return emptyList(),
+            }
-                            messageIds = currentGroup.map { it.messageId }
+        }.sortedBy { it.first }
+
+        val sent = mutableListOf<MessageMetaInfo>()
+        val leftToSend = ordersWithMessagesGroups.map { it.second }.toMutableList()
+
+        return ordersWithMessagesGroups.flatMap { (_, contents) ->
+            val sourceMessagesToSentMessages = mutableListOf<Pair<MessageMetaInfo, MessageMetaInfo>>()
+
+            onBetweenMessages(sent.toList(), leftToSend.flatten())
+
+            when {
+                contents.size == 1 -> {
+                    val messageInfo = contents.first()
+                    runCatching {
+                        MessageMetaInfo(
+                            targetChatId,
+                            bot.execute(
+                                CopyMessage(
+                                    toChatId = targetChatId,
+                                    fromChatId = messageInfo.chatId,
+                                    messageId = messageInfo.messageId,
+                                )
+                            )
                         )
-                    ).mapIndexed { i, newMessageId ->
+                    }.onFailure { _ ->
-                        currentGroup[i] to MessageMetaInfo(targetChatId, newMessageId)
+                        runCatching {
-                    }.also {
+                            bot.execute(
-                        currentGroup.clear()
+                                ForwardMessage(
+                                    toChatId = targetChatId,
+                                    fromChatId = messageInfo.chatId,
+                                    messageId = messageInfo.messageId
+                                )
+                            )
+                        }.onSuccess {
+                            MessageMetaInfo(
+                                targetChatId,
+                                bot.execute(
+                                    CopyMessage(
+                                        toChatId = targetChatId,
+                                        fromChatId = it.chat.id,
+                                        messageId = it.messageId
+                                    )
+                                )
+                            )
+                        }
+                    }.getOrNull() ?.let {
+                        sourceMessagesToSentMessages.add(messageInfo to it)
                     }
-                }.getOrElse {
+                }
-                    currentGroup.applyDiff(
+                else -> {
-                        currentGroup.filter {
+                    val resultContents = contents.mapNotNull {
-                            runCatching {
+                        it to (
                                 bot.execute(
                                     ForwardMessage(
                                         toChatId = cacheChatId,
                                         fromChatId = it.chatId,
                                         messageId = it.messageId
                                     )
-                                )
+                                ) as? ContentMessage<*> ?: return@mapNotNull null)
-                            }.isSuccess
+                    }.mapNotNull { (src, forwardedMessage) ->
+                        val forwardedMessageAsMediaPartMessage = forwardedMessage.takeIf {
+                            it.content is MediaGroupPartContent
+                        } ?.let {
+                            it as ContentMessage<MediaGroupPartContent>
                         }
-                    )
+                        src to (forwardedMessageAsMediaPartMessage ?: null.also { _ ->
-                    null
+                            sourceMessagesToSentMessages.add(
-                } ?: continue
+                                src to MessageMetaInfo(
-            }
+                                    targetChatId,
-            return emptyList()
+                                    bot.execute(
-        }
+                                        CopyMessage(
+                                            toChatId = targetChatId,
+                                            fromChatId = forwardedMessage.chat.id,
+                                            messageId = forwardedMessage.messageId
+                                        )
+                                    )
+                                )
+                            )
+                        } ?: return@mapNotNull null)
+                    }
 
-        val copied = mutableListOf<Pair<MessageMetaInfo, MessageMetaInfo>>()
+                    resultContents.singleOrNull() ?.also { (src, it) ->
-        for (content in messagesInfo) {
+                        sourceMessagesToSentMessages.add(
-            when {
+                            src to MessageMetaInfo(
-                currentGroup.isEmpty() ||
+                                targetChatId,
-                currentGroup.first().chatId == content.chatId -> currentGroup.add(content)
+                                bot.execute(
-                else -> {
+                                    CopyMessage(
-                    onBetweenMessages(copied.map { it.first }, currentGroup.toList())
+                                        toChatId = targetChatId,
-                    copied.addAll(makeCopy())
+                                        fromChatId = it.chat.id,
+                                        messageId = it.messageId
+                                    )
+                                )
+                            )
+                        )
+                    } ?: resultContents.chunked(mediaCountInMediaGroup.last).forEach {
+                        bot.execute(
+                            SendMediaGroup<MediaGroupPartContent>(
+                                targetChatId,
+                                it.map { it.second.content.toMediaGroupMemberTelegramMedia() }
+                            )
+                        ).content.group.mapIndexed { i, partWrapper ->
+                            it.getOrNull(i) ?.let {
+                                sourceMessagesToSentMessages.add(
+                                    it.first to MessageMetaInfo(
+                                        partWrapper.sourceMessage.chat.id,
+                                        partWrapper.sourceMessage.messageId,
+                                        partWrapper.sourceMessage.mediaGroupId
+                                    )
+                                )
+                            }
+                        }
+                    }
                 }
             }
+
+            leftToSend.takeIf { it.isNotEmpty() } ?.removeAt(0) ?.also {
+                sent.addAll(it)
+            }
+            sourceMessagesToSentMessages.toList()
         }
-        if (currentGroup.isNotEmpty()) {
-            onBetweenMessages(copied.map { it.first }, currentGroup.toList())
-            copied.addAll(makeCopy())
-        }
-        return copied.toList()
     }
 
     suspend fun resend(