update plagubot version

0.15.0

.github/workflows/commit-publish.yml

@@ -8,9 +8,6 @@ jobs:
       - uses: actions/setup-java@v1
         with:
           java-version: 11
-      - name: Fix android 32.0.0 dx
-        continue-on-error: true
-        run: cd /usr/local/lib/android/sdk/build-tools/32.0.0/ && mv d8 dx && cd lib  && mv d8.jar dx.jar
       - name: Update version
         run: |
           branch="`echo "${{ github.ref }}" | grep -o "[^/]*$"`"

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

@@ -1,6 +1,6 @@
 package dev.inmo.tgbotapi.libraries.cache.admins
 
-import com.soywiz.klock.minutes
+import korlibs.time.minutes
 import dev.inmo.tgbotapi.types.IdChatIdentifier
 import dev.inmo.tgbotapi.types.Seconds
 import kotlinx.coroutines.flow.SharedFlow

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

@@ -1,6 +1,6 @@
 package dev.inmo.tgbotapi.libraries.cache.admins
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.chat.members.getChatMember

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

@@ -1,6 +1,6 @@
 package dev.inmo.tgbotapi.libraries.cache.admins.micro_utils
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 import dev.inmo.micro_utils.coroutines.*
 import dev.inmo.micro_utils.repos.*
 import dev.inmo.tgbotapi.libraries.cache.admins.DefaultAdminsCacheAPIRepo

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

@@ -1,7 +1,7 @@
 package dev.inmo.tgbotapi.libraries.cache.media.common
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
-import com.soywiz.klock.milliseconds
+import korlibs.time.milliseconds
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.DeleteMessage
 import dev.inmo.tgbotapi.requests.abstracts.FileId

gradle.properties

@@ -4,25 +4,23 @@ org.gradle.parallel=true
 kotlin.js.generate.externals=true
 kotlin.incremental=true
 kotlin.incremental.js=true
-android.useAndroidX=true
-android.enableJetifier=true
 
 
-kotlin_version=1.7.22
+kotlin_version=1.8.22
-kotlin_serialisation_core_version=1.4.1
+kotlin_serialisation_core_version=1.5.1
 
 github_release_plugin_version=2.4.1
 
-tgbotapi_version=4.2.3
+tgbotapi_version=9.2.1
-micro_utils_version=0.16.4
+micro_utils_version=0.19.9
 exposed_version=0.41.1
-plagubot_version=3.2.3
+plagubot_version=7.2.1
 
 # Dokka
 
-dokka_version=1.7.20
+dokka_version=1.8.20
 
 # Project data
 
 group=dev.inmo
-version=0.6.8
+version=0.15.1

gradle/wrapper/gradle-wrapper.properties

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

resender/build.gradle

@@ -0,0 +1,17 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+}
+
+apply from: "$mppJavaWithJsProjectPath"
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api "dev.inmo:tgbotapi.core:$tgbotapi_version"
+            }
+        }
+    }
+}
+

resender/src/commonMain/kotlin/MessageMetaInfo.kt

@@ -0,0 +1,20 @@
+package dev.inmo.tgbotapi.libraries.resender
+
+import dev.inmo.tgbotapi.types.FullChatIdentifierSerializer
+import dev.inmo.tgbotapi.types.IdChatIdentifier
+import dev.inmo.tgbotapi.types.MessageId
+import dev.inmo.tgbotapi.types.message.abstracts.Message
+import dev.inmo.tgbotapi.types.message.abstracts.PossiblyMediaGroupMessage
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class MessageMetaInfo(
+    @Serializable(FullChatIdentifierSerializer::class)
+    val chatId: IdChatIdentifier,
+    val messageId: MessageId,
+    val group: String? = null
+)
+
+operator fun MessageMetaInfo.Companion.invoke(
+    message: Message
+) = MessageMetaInfo(message.chat.id, message.messageId, (message as? PossiblyMediaGroupMessage<*>) ?.mediaGroupId)

resender/src/commonMain/kotlin/MessagesResender.kt

@@ -0,0 +1,157 @@
+package dev.inmo.tgbotapi.libraries.resender
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.ForwardMessage
+import dev.inmo.tgbotapi.requests.send.CopyMessage
+import dev.inmo.tgbotapi.requests.send.media.SendMediaGroup
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.IdChatIdentifier
+import dev.inmo.tgbotapi.types.mediaCountInMediaGroup
+import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
+import dev.inmo.tgbotapi.types.message.content.MediaGroupPartContent
+
+class MessagesResender(
+    private val bot: TelegramBot,
+    private val cacheChatId: ChatIdentifier
+) {
+    suspend fun resend(
+        targetChatId: IdChatIdentifier,
+        messagesInfo: List<MessageMetaInfo>,
+        onBetweenMessages: suspend (sent: List<MessageMetaInfo>, toBeSent: List<MessageMetaInfo>) -> Unit
+    ): List<Pair<MessageMetaInfo, MessageMetaInfo>> {
+        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)
+                }
+            } 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
+                                )
+                            ) 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
+                                        )
+                                    )
+                                )
+                            )
+                        } ?: return@mapNotNull null)
+                    }
+
+                    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
+                                    )
+                                )
+                            }
+                        }
+                    }
+                }
+            }
+
+            leftToSend.takeIf { it.isNotEmpty() } ?.removeAt(0) ?.also {
+                sent.addAll(it)
+            }
+            sourceMessagesToSentMessages.toList()
+        }
+    }
+
+    suspend fun resend(
+        targetChatId: IdChatIdentifier,
+        messagesInfo: List<MessageMetaInfo>
+    ): List<Pair<MessageMetaInfo, MessageMetaInfo>> = resend(targetChatId, messagesInfo) { _, _ -> }
+}

settings.gradle

@@ -7,6 +7,8 @@ String[] includes = [
 
     ":cache:content:common",
     ":cache:content:micro_utils",
+
+    ":resender",
 ]