Update tgbotapi_version to v30.0.1-branch_30.0.1-build3013

0.27.0

.gitignore

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

build.gradle

@@ -13,6 +13,23 @@ buildscript {
     }
 }
 
+plugins {
+    id "com.gradleup.nmcp.aggregation" version "$nmcp_version"
+}
+
+if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
+    nmcpAggregation {
+        centralPortal {
+            username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
+            password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
+            validationTimeout = Duration.ofHours(4)
+            publishingType = System.getenv('PUBLISHING_TYPE') != "" ? System.getenv('PUBLISHING_TYPE') : "USER_MANAGED"
+        }
+
+        publishAllProjectsProbablyBreakingProjectIsolation()
+    }
+}
+
 allprojects {
     repositories {
         mavenLocal()

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

@@ -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>(
-                    keyFromToTo = { chatId },
+                ).withMapper<IdChatIdentifier, AdministratorChatMember, Long, String>(
+                    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>(
-                    keyFromToTo = { chatId },
+                ).withMapper<IdChatIdentifier, Long, Long, Long>(
+                    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>(
-                    keyFromToTo = { chatId },
+                ).withMapper<IdChatIdentifier, AdminsCacheSettings, Long, String>(
+                    keyFromToTo = { chatId.long },
                     valueFromToTo = { telegramAdminsSerializationFormat.encodeToString(this) },
                     keyToToFrom = { toChatId() },
                     valueToToFrom = { telegramAdminsSerializationFormat.decodeFromString(this) }

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

@@ -1,11 +1,15 @@
 package dev.inmo.tgbotapi.libraries.cache.media.common
 
 import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.DeleteMessage
 import dev.inmo.tgbotapi.requests.DownloadFileStream
+import dev.inmo.tgbotapi.requests.abstracts.MultipartFile
 import dev.inmo.tgbotapi.requests.get.GetFile
 import dev.inmo.tgbotapi.requests.send.media.*
 import dev.inmo.tgbotapi.types.IdChatIdentifier
 import dev.inmo.tgbotapi.types.media.*
+import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
+import dev.inmo.tgbotapi.types.message.content.DocumentContent
 import dev.inmo.tgbotapi.types.message.content.MediaContent
 import dev.inmo.tgbotapi.types.message.content.MessageContent
 import dev.inmo.tgbotapi.utils.asInput
@@ -58,6 +62,30 @@ class DefaultMessageContentCache<K>(
         }
     }
 
+    override suspend fun sendAndSave(
+        k: K,
+        filename: String,
+        inputAllocator: () -> Input
+    ): DocumentContent {
+        val sentDocument = bot.execute(
+            SendDocument(
+                filesRefreshingChatId,
+                MultipartFile(filename, inputAllocator),
+            )
+        )
+        save(k, sentDocument.content, filename, inputAllocator)
+        runCatching {
+            bot.execute(
+                DeleteMessage(
+                    sentDocument.chat.id,
+                    sentDocument.messageId
+                )
+            )
+        }
+
+        return sentDocument.content
+    }
+
     override suspend fun get(k: K): MessageContent? {
         val savedSimpleContent = simpleMessageContentCache.get(k) ?: return null
 

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

@@ -1,5 +1,7 @@
 package dev.inmo.tgbotapi.libraries.cache.media.common
 
+import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
+import dev.inmo.tgbotapi.types.message.content.DocumentContent
 import dev.inmo.tgbotapi.types.message.content.MediaContent
 import dev.inmo.tgbotapi.types.message.content.MessageContent
 import io.ktor.utils.io.core.Input
@@ -12,6 +14,11 @@ interface MessageContentCache<K> {
         filename: String,
         inputAllocator: suspend () -> Input
     )
+    suspend fun sendAndSave(
+        k: K,
+        filename: String,
+        inputAllocator: () -> Input
+    ): DocumentContent
 
     suspend fun get(k: K): MessageContent?
     suspend fun contains(k: K): Boolean

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.asOutput
+import io.ktor.utils.io.streams.*
 import java.io.File
 
 class InFilesMessagesFilesCache<K>(
@@ -39,8 +38,8 @@ class InFilesMessagesFilesCache<K>(
         val file = File(folderFile, fullFileName).apply {
             delete()
         }
-        inputAllocator().use { input ->
-            file.outputStream().asOutput().use { output ->
+        inputAllocator().inputStream().use { input ->
+            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,23 @@ kotlin.incremental=true
 kotlin.incremental.js=true
 
 
-kotlin_version=1.9.22
-kotlin_serialisation_core_version=1.6.2
+kotlin_version=2.2.20
+kotlin_serialisation_core_version=1.9.0
 
 github_release_plugin_version=2.5.2
 
-tgbotapi_version=10.1.0
-micro_utils_version=0.20.35
-exposed_version=0.47.0
-plagubot_version=8.2.0
+tgbotapi_version=30.0.1-branch_30.0.1-build3013
+micro_utils_version=0.26.6
+exposed_version=0.61.0
+plagubot_version=10.9.0
+
+nmcp_version=1.2.0
 
 # Dokka
 
-dokka_version=1.9.10
+dokka_version=2.1.0
 
 # Project data
 
 group=dev.inmo
-version=0.18.2
+version=0.27.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.13-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>()
-        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(
+                                    toChatId = 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(
+                                        toChatId = 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(
+                                            toChatId = 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(
+                                        toChatId = targetChatId,
+                                        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
+                                    )
+                                )
                             }
                         }
                     }
-        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(