InsanusMokrassar/TelegramBotApiLibraries
1
0
Fork 0
mirror of https://github.com/InsanusMokrassar/TelegramBotApiLibraries.git synced 2024-12-22 08:37:16 +00:00
Code Issues Projects Releases Wiki Activity

improvements in MessagesResender

Browse Source
This commit is contained in:
InsanusMokrassar 2024-01-13 14:37:21 +06:00
parent f19664da58
commit 4057d5167f
4 changed files with 64 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
cache/admins/common/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/admins/AdminsCacheSettingsAPI.kt vendored
View File

@ -3,6 +3,7 @@ package dev.inmo.tgbotapi.libraries.cache.admins
import korlibs.time.minutes
import dev.inmo.tgbotapi.types.IdChatIdentifier
import dev.inmo.tgbotapi.types.Seconds
import korlibs.time.seconds
import kotlinx.coroutines.flow.SharedFlow
import kotlinx.serialization.Serializable

1
cache/admins/common/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/admins/DefaultAdminsCacheAPI.kt vendored
View File

@ -8,6 +8,7 @@ import dev.inmo.tgbotapi.types.*
import dev.inmo.tgbotapi.types.chat.ExtendedBot
import dev.inmo.tgbotapi.types.chat.member.AdministratorChatMember
import dev.inmo.tgbotapi.types.message.abstracts.*
import korlibs.time.seconds
import kotlinx.serialization.Serializable
interface DefaultAdminsCacheAPIRepo {

17
resender/src/commonMain/kotlin/MessageMetaInfo.kt
View File

@ -3,8 +3,10 @@ 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.ContentMessage
import dev.inmo.tgbotapi.types.message.abstracts.Message
import dev.inmo.tgbotapi.types.message.abstracts.PossiblyMediaGroupMessage
import dev.inmo.tgbotapi.types.message.content.MediaGroupContent
import kotlinx.serialization.Serializable
@Serializable
@ -13,7 +15,20 @@ data class MessageMetaInfo(
val chatId: IdChatIdentifier,
val messageId: MessageId,
val group: String? = null
)
) {
val metaInfo: Message.MetaInfo
get() = Message.MetaInfo(chatId, messageId)
}
fun Message.asMessageMetaInfos(): List<MessageMetaInfo> {
return if (this is ContentMessage<*>) {
(content as? MediaGroupContent<*>) ?.group ?.map {
MessageMetaInfo(it.sourceMessage.chat.id, it.sourceMessage.messageId, it.sourceMessage.mediaGroupId)
}
} else {
null
} ?: listOf(MessageMetaInfo(chat.id, messageId, (this as? PossiblyMediaGroupMessage<*>) ?.mediaGroupId))
}
operator fun MessageMetaInfo.Companion.invoke(
message: Message

147
resender/src/commonMain/kotlin/MessagesResender.kt
View File

@ -1,8 +1,10 @@
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.send.CopyMessage
import dev.inmo.tgbotapi.requests.send.CopyMessages
import dev.inmo.tgbotapi.requests.send.media.SendMediaGroup
import dev.inmo.tgbotapi.types.ChatIdentifier
import dev.inmo.tgbotapi.types.IdChatIdentifier
@ -19,135 +21,58 @@ class MessagesResender(
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,
val currentGroup = mutableListOf<MessageMetaInfo>()
suspend fun makeCopy(): List<Pair<MessageMetaInfo, MessageMetaInfo>> {
currentGroup.sortBy { it.messageId }
while (currentGroup.isNotEmpty()) {
return runCatching {
bot.execute(
CopyMessage(
targetChatId,
fromChatId = messageInfo.chatId,
messageId = messageInfo.messageId
)
)
)
}.onFailure { _ ->
runCatching {
bot.execute(
ForwardMessage(
CopyMessages(
toChatId = targetChatId,
fromChatId = messageInfo.chatId,
messageId = messageInfo.messageId
)
)
}.onSuccess {
MessageMetaInfo(
targetChatId,
bot.execute(
CopyMessage(
targetChatId,
fromChatId = it.chat.id,
messageId = it.messageId
)
)
fromChatId = currentGroup.firstOrNull() ?.chatId ?: return emptyList(),
messageIds = currentGroup.map { it.messageId }
)
).mapIndexed { i, newMessageId ->
currentGroup[i] to MessageMetaInfo(targetChatId, newMessageId)
}.also {
currentGroup.clear()
}
}.getOrNull() ?.let {
sourceMessagesToSentMessages.add(messageInfo to it)
}
}
else -> {
val resultContents = contents.mapNotNull {
it to (
}.getOrElse {
currentGroup.applyDiff(
currentGroup.filter {
runCatching {
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>
)
}.isSuccess
}
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)
null
} ?: continue
}
return emptyList()
}
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
)
)
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())
}
}
}
if (currentGroup.isNotEmpty()) {
onBetweenMessages(copied.map { it.first }, currentGroup.toList())
copied.addAll(makeCopy())
}
}
leftToSend.takeIf { it.isNotEmpty() } ?.removeAt(0) ?.also {
sent.addAll(it)
}
sourceMessagesToSentMessages.toList()
}
return copied.toList()
}
suspend fun resend(