InsanusMokrassar
/
TelegramBotApiLibraries
mirror of https://github.com/InsanusMokrassar/TelegramBotApiLibraries.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

revert algorithm of messages resender

This commit is contained in:
InsanusMokrassar 2024-02-21 02:22:45 +06:00
parent 90870c225c
commit 66934c823d
1 changed files with 117 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -3,6 +3,7 @@ package dev.inmo.tgbotapi.libraries.resender
import dev.inmo.micro_utils.common.applyDiff import dev.inmo.micro_utils.common.applyDiff
import dev.inmo.tgbotapi.bot.TelegramBot import dev.inmo.tgbotapi.bot.TelegramBot
import dev.inmo.tgbotapi.requests.ForwardMessage 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.CopyMessage
import dev.inmo.tgbotapi.requests.send.CopyMessages import dev.inmo.tgbotapi.requests.send.CopyMessages
import dev.inmo.tgbotapi.requests.send.media.SendMediaGroup import dev.inmo.tgbotapi.requests.send.media.SendMediaGroup
@ -21,58 +22,135 @@ class MessagesResender(
messagesInfo: List<MessageMetaInfo>, messagesInfo: List<MessageMetaInfo>,
onBetweenMessages: suspend (sent: List<MessageMetaInfo>, toBeSent: List<MessageMetaInfo>) -> Unit onBetweenMessages: suspend (sent: List<MessageMetaInfo>, toBeSent: List<MessageMetaInfo>) -> Unit
): List<Pair<MessageMetaInfo, MessageMetaInfo>> { ): 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(
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(
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( bot.execute(
ForwardMessage( ForwardMessage(
toChatId = cacheChatId, toChatId = cacheChatId,
fromChatId = it.chatId, fromChatId = it.chatId,
messageId = it.messageId 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(
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()) targetChatId,
copied.addAll(makeCopy()) 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()
} }
if (currentGroup.isNotEmpty()) {
onBetweenMessages(copied.map { it.first }, currentGroup.toList())
copied.addAll(makeCopy())
}
return copied.toList()
} }
suspend fun resend( suspend fun resend(