start 0.23.0 && update dependencies

0.22.0

.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>(
-            keyFromToTo = { chatId },
+        ).withMapper<IdChatIdentifier, AdministratorChatMember, Long, String>(
+            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>(
-            keyFromToTo = { chatId },
+        ).withMapper<IdChatIdentifier, Long, Long, Long>(
+            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>(
-            keyFromToTo = { chatId },
+        ).withMapper<IdChatIdentifier, AdminsCacheSettings, Long, String>(
+            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

@@ -55,8 +55,8 @@ class AdminsPlugin : Plugin {
                     { long("chatId") },
                     { text("member") },
                     "AdminsTable"
-                ).withMapper<IdChatIdentifier, AdministratorChatMember, Identifier, String>(
-                    keyFromToTo = { chatId },
+                ).withMapper<IdChatIdentifier, AdministratorChatMember, Long, String>(
+                    keyFromToTo = { chatId.long },
                     valueFromToTo = { telegramAdminsSerializationFormat.encodeToString(this) },
                     keyToToFrom = { toChatId() },
                     valueToToFrom = { telegramAdminsSerializationFormat.decodeFromString(this) }
@@ -66,8 +66,8 @@ class AdminsPlugin : Plugin {
                     { long("chatId") },
                     { long("datetime") },
                     "AdminsUpdatesTimesTable"
-                ).withMapper<IdChatIdentifier, Long, Identifier, Long>(
-                    keyFromToTo = { chatId },
+                ).withMapper<IdChatIdentifier, Long, Long, Long>(
+                    keyFromToTo = { chatId.long },
                     valueFromToTo = { this },
                     keyToToFrom = { toChatId() },
                     valueToToFrom = { this }
@@ -82,8 +82,8 @@ class AdminsPlugin : Plugin {
                     { long("chatId") },
                     { text("settings") },
                     "DynamicAdminsCacheSettingsAPI"
-                ).withMapper<IdChatIdentifier, AdminsCacheSettings, Identifier, String>(
-                    keyFromToTo = { chatId },
+                ).withMapper<IdChatIdentifier, AdminsCacheSettings, Long, String>(
+                    keyFromToTo = { chatId.long },
                     valueFromToTo = { telegramAdminsSerializationFormat.encodeToString(this) },
                     keyToToFrom = { toChatId() },
                     valueToToFrom = { telegramAdminsSerializationFormat.decodeFromString(this) }

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_serialisation_core_version=1.6.2
+kotlin_version=2.0.20
+kotlin_serialisation_core_version=1.7.2
 
-github_release_plugin_version=2.4.1
+github_release_plugin_version=2.5.2
 
-tgbotapi_version=10.0.0
-micro_utils_version=0.20.26
-exposed_version=0.46.0
-plagubot_version=8.0.0
+tgbotapi_version=18.0.0
+micro_utils_version=0.22.2
+exposed_version=0.54.0
+plagubot_version=9.2.0
 
 # Dokka
 
-dokka_version=1.9.10
+dokka_version=1.9.20
 
 # Project data
 
 group=dev.inmo
-version=0.18.0
+version=0.23.0

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.9-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')
             }
         }
     }

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>()
-        suspend fun makeCopy(): List<Pair<MessageMetaInfo, MessageMetaInfo>> {
-            currentGroup.sortBy { it.messageId }
-            while (currentGroup.isNotEmpty()) {
-                return runCatching {
-                    bot.execute(
-                        CopyMessages(
-                            toChatId = targetChatId,
-                            fromChatId = currentGroup.firstOrNull() ?.chatId ?: return emptyList(),
-                            messageIds = currentGroup.map { it.messageId }
-                        )
-                    ).mapIndexed { i, newMessageId ->
-                        currentGroup[i] to MessageMetaInfo(targetChatId, newMessageId)
-                    }.also {
-                        currentGroup.clear()
+        val messagesWithOrders = messagesInfo.mapIndexed { i, messageInfo -> messageInfo to i }.toMap()
+        val ordersWithMessagesGroups = messagesInfo.groupBy { it.group }.flatMap { (group, list) ->
+            if (group == null) {
+                list.map {
+                    messagesWithOrders.getValue(it) to listOf(it)
                 }
-                }.getOrElse {
-                    currentGroup.applyDiff(
-                        currentGroup.filter {
+            } else {
+                listOf(messagesWithOrders.getValue(list.first()) to list)
+            }
+        }.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(
+                                    targetChatId,
+                                    fromChatId = messageInfo.chatId,
+                                    messageId = messageInfo.messageId
+                                )
+                            )
+                        )
+                    }.onFailure { _ ->
+                        runCatching {
+                            bot.execute(
+                                ForwardMessage(
+                                    toChatId = targetChatId,
+                                    fromChatId = messageInfo.chatId,
+                                    messageId = messageInfo.messageId
+                                )
+                            )
+                        }.onSuccess {
+                            MessageMetaInfo(
+                                targetChatId,
+                                bot.execute(
+                                    CopyMessage(
+                                        targetChatId,
+                                        fromChatId = it.chat.id,
+                                        messageId = it.messageId
+                                    )
+                                )
+                            )
+                        }
+                    }.getOrNull() ?.let {
+                        sourceMessagesToSentMessages.add(messageInfo to it)
+                    }
+                }
+                else -> {
+                    val resultContents = contents.mapNotNull {
+                        it to (
                                 bot.execute(
                                     ForwardMessage(
                                         toChatId = cacheChatId,
                                         fromChatId = it.chatId,
                                         messageId = it.messageId
                                     )
-                                )
-                            }.isSuccess
+                                ) as? ContentMessage<*> ?: return@mapNotNull null)
+                    }.mapNotNull { (src, forwardedMessage) ->
+                        val forwardedMessageAsMediaPartMessage = forwardedMessage.takeIf {
+                            it.content is MediaGroupPartContent
+                        } ?.let {
+                            it as ContentMessage<MediaGroupPartContent>
                         }
+                        src to (forwardedMessageAsMediaPartMessage ?: null.also { _ ->
+                            sourceMessagesToSentMessages.add(
+                                src to MessageMetaInfo(
+                                    targetChatId,
+                                    bot.execute(
+                                        CopyMessage(
+                                            targetChatId,
+                                            fromChatId = forwardedMessage.chat.id,
+                                            messageId = forwardedMessage.messageId
                                         )
-                    null
-                } ?: continue
-            }
-            return emptyList()
+                                    )
+                                )
+                            )
+                        } ?: return@mapNotNull null)
                     }
 
-        val copied = mutableListOf<Pair<MessageMetaInfo, MessageMetaInfo>>()
-        for (content in messagesInfo) {
-            when {
-                currentGroup.isEmpty() ||
-                currentGroup.first().chatId == content.chatId -> currentGroup.add(content)
-                else -> {
-                    onBetweenMessages(copied.map { it.first }, currentGroup.toList())
-                    copied.addAll(makeCopy())
+                    resultContents.singleOrNull() ?.also { (src, it) ->
+                        sourceMessagesToSentMessages.add(
+                            src to MessageMetaInfo(
+                                targetChatId,
+                                bot.execute(
+                                    CopyMessage(
+                                        targetChatId,
+                                        it.chat.id,
+                                        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
+                                    )
+                                )
                             }
                         }
                     }
-        if (currentGroup.isNotEmpty()) {
-            onBetweenMessages(copied.map { it.first }, currentGroup.toList())
-            copied.addAll(makeCopy())
                 }
-        return copied.toList()
+            }
+
+            leftToSend.takeIf { it.isNotEmpty() } ?.removeAt(0) ?.also {
+                sent.addAll(it)
+            }
+            sourceMessagesToSentMessages.toList()
+        }
     }
 
     suspend fun resend(