update up to 0.35.1

FilesLoaderBot/src/main/kotlin/FilesLoaderBot.kt

@@ -1,14 +1,12 @@
-import dev.inmo.micro_utils.coroutines.safely
-import dev.inmo.tgbotapi.bot.Ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.downloadFile
 import dev.inmo.tgbotapi.extensions.api.get.getFileAdditionalInfo
-import dev.inmo.tgbotapi.extensions.utils.flatMap
+import dev.inmo.tgbotapi.extensions.api.send.reply
-import dev.inmo.tgbotapi.extensions.utils.shortcuts.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviour
-import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.longPolling
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
-import dev.inmo.tgbotapi.types.message.content.abstracts.MediaContent
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onMedia
 import dev.inmo.tgbotapi.utils.filenameFromUrl
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.Dispatchers
 import java.io.File
 
 /**
@@ -19,24 +17,15 @@ suspend fun main(args: Array<String>) {
     val directoryOrFile = args.getOrNull(1) ?.let { File(it) } ?: File("")
     directoryOrFile.mkdirs()
 
-    val bot = telegramBot(botToken)
+    telegramBotWithBehaviour(botToken, CoroutineScope(Dispatchers.IO)) {
-    val scope = CoroutineScope(Dispatchers.Default)
+        onMedia(includeMediaGroups = true) {
-
+            val pathedFile = bot.getFileAdditionalInfo(it.content.media)
-    bot.longPolling(scope = scope) {
+            val file = File(directoryOrFile, pathedFile.filePath.filenameFromUrl).apply {
-        val flow = merge (
+                createNewFile()
-            filterContentMessages<MediaContent>(),
+                writeBytes(bot.downloadFile(pathedFile))
-            mediaGroupMessages().flatMap()
-        )
-        flow.onEach {
-            safely({ it.printStackTrace() }) {
-                val pathedFile = bot.getFileAdditionalInfo(it.content.media)
-                File(directoryOrFile, pathedFile.filePath.filenameFromUrl).apply {
-                    createNewFile()
-                    writeBytes(bot.downloadFile(pathedFile))
-                }
             }
-        }.launchIn(scope)
+            reply(it, "Saved to ${file.absolutePath}")
-    }
+        }
-
+        onContentMessage { println(it) }
-    scope.coroutineContext[Job]!!.join()
+    }.second.join()
 }

ForwardInfoSenderBot/src/main/kotlin/ForwardInfoSenderBot.kt

@@ -1,17 +1,12 @@
-import dev.inmo.micro_utils.coroutines.safely
+import dev.inmo.micro_utils.coroutines.defaultSafelyExceptionHandler
 import dev.inmo.tgbotapi.bot.Ktor.telegramBot
-import dev.inmo.tgbotapi.extensions.api.send.sendTextMessage
+import dev.inmo.tgbotapi.extensions.api.send.reply
-import dev.inmo.tgbotapi.extensions.api.telegramBot
+import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviour
-import dev.inmo.tgbotapi.extensions.utils.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
-import dev.inmo.tgbotapi.extensions.utils.formatting.codeMarkdownV2
+import dev.inmo.tgbotapi.extensions.utils.formatting.*
-import dev.inmo.tgbotapi.extensions.utils.formatting.regularMarkdownV2
-import dev.inmo.tgbotapi.extensions.utils.shortcuts.mediaGroupMessages
-import dev.inmo.tgbotapi.extensions.utils.updates.asContentMessagesFlow
-import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.longPolling
 import dev.inmo.tgbotapi.types.ParseMode.MarkdownV2
 import dev.inmo.tgbotapi.types.message.*
 import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.*
 
 /**
  * This bot will always return message about forwarder. In cases when sent message was not a forward message it will
@@ -20,26 +15,25 @@ import kotlinx.coroutines.flow.*
 suspend fun main(vararg args: String) {
     val botToken = args.first()
 
-    val bot = telegramBot(botToken)
+    telegramBotWithBehaviour(botToken, CoroutineScope(Dispatchers.IO)) {
-
+        onContentMessage(includeMediaGroups = true) {
-    val scope = CoroutineScope(Dispatchers.Default)
+            val toAnswer = buildEntities {
-
+                when (val forwardInfo = it.forwardInfo) {
-    bot.longPolling(scope = scope) {
+                    null -> +"There is no forward info"
-        (merge(messageFlow.asContentMessagesFlow(), mediaGroupMessages(scope).flatMap())).mapNotNull { it.asPossiblyForwardedMessage() }.onEach { message ->
+                    is AnonymousForwardInfo -> {
-            safely({ it.printStackTrace() }) {
+                        regular("Anonymous user which signed as \"") + code(forwardInfo.senderName) + "\""
-                val toAnswer = when (val forwardInfo = message.forwardInfo) {
-                    null -> "There is no forward info"
-                    is AnonymousForwardInfo -> "Anonymous user which signed as \"${forwardInfo.senderName.codeMarkdownV2()}\""
-                    is UserForwardInfo -> forwardInfo.from.let { user ->
-                        "User ${user.id.chatId.toString().codeMarkdownV2()} " + "(${user.firstName} ${user.lastName}: ${user.username ?.username ?: "Without username"})".regularMarkdownV2()
                     }
-                    is ForwardFromChannelInfo -> "Channel (".regularMarkdownV2() + (forwardInfo.channelChat).title.codeMarkdownV2() + ")".regularMarkdownV2()
+                    is UserForwardInfo -> {
-                    is ForwardFromSupergroupInfo -> "Supergroup (".regularMarkdownV2() + (forwardInfo.group).title.codeMarkdownV2() + ")".regularMarkdownV2()
+                        val user = forwardInfo.from
+                        regular("User ") + code(user.id.chatId.toString()) + " (${user.firstName} ${user.lastName}: ${user.username ?.username ?: "Without username"})"
+                    }
+                    is ForwardFromChannelInfo -> regular("Channel (") + code((forwardInfo.channelChat).title) + ")"
+                    is ForwardFromSupergroupInfo -> regular("Supergroup (") + code((forwardInfo.group).title) + ")"
                 }
-                bot.sendTextMessage(message.chat, toAnswer, MarkdownV2)
             }
-        }.launchIn(scope)
+            reply(it, toAnswer)
-    }
+            coroutineContext.job.invokeOnCompletion { println("completance of onContentMessage") }
-
+        }
-    scope.coroutineContext[Job]!!.join()
+        coroutineContext.job.invokeOnCompletion { println("Completed :)") }
+    }.second.join()
 }

HelloBot/src/main/kotlin/HelloBot.kt

@@ -3,6 +3,8 @@ import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
 import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.api.send.sendTextMessage
 import dev.inmo.tgbotapi.bot.Ktor.telegramBot
+import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviour
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
 import dev.inmo.tgbotapi.extensions.utils.asChannelChat
 import dev.inmo.tgbotapi.extensions.utils.formatting.linkMarkdownV2
 import dev.inmo.tgbotapi.extensions.utils.formatting.textMentionMarkdownV2
@@ -21,41 +23,30 @@ import kotlinx.coroutines.flow.onEach
 suspend fun main(vararg args: String) {
     val botToken = args.first()
 
-    val bot = telegramBot(botToken)
+    telegramBotWithBehaviour(botToken, CoroutineScope(Dispatchers.IO)) {
-
+        onContentMessage { message ->
-    val scope = CoroutineScope(Dispatchers.Default)
+            val chat = message.chat
-
+            if (chat is ChannelChat) {
-    bot.longPolling(scope = scope) {
+                val answer = "Hi everybody in this channel \"${chat.title}\""
-        messageFlow.onEach {
+                sendTextMessage(chat, answer, MarkdownV2)
-            safely {
+                return@onContentMessage
-                val message = it.data
-                val chat = message.chat
-                val answerText = "Oh, hi, " + when (chat) {
-                    is PrivateChat -> "${chat.firstName} ${chat.lastName}".textMentionMarkdownV2(chat.id)
-                    is User -> "${chat.firstName} ${chat.lastName}".textMentionMarkdownV2(chat.id)
-                    is SupergroupChat -> (chat.username ?.username ?: bot.getChat(chat).inviteLink) ?.let {
-                        chat.title.linkMarkdownV2(it)
-                    } ?: chat.title
-                    is GroupChat -> bot.getChat(chat).inviteLink ?.let {
-                        chat.title.linkMarkdownV2(it)
-                    } ?: chat.title
-                    else -> "Unknown :(".escapeMarkdownV2Common()
-                }
-                bot.reply(
-                    message,
-                    answerText,
-                    MarkdownV2
-                )
             }
-        }.launchIn(scope)
+            val answerText = "Oh, hi, " + when (chat) {
-        channelPostFlow.onEach {
+                is PrivateChat -> "${chat.firstName} ${chat.lastName}".textMentionMarkdownV2(chat.id)
-            safely {
+                is User -> "${chat.firstName} ${chat.lastName}".textMentionMarkdownV2(chat.id)
-                val chat = it.data.chat
+                is SupergroupChat -> (chat.username ?.username ?: getChat(chat).inviteLink) ?.let {
-                val message = "Hi everybody in this channel \"${(chat.asChannelChat()) ?.title}\""
+                    chat.title.linkMarkdownV2(it)
-                bot.sendTextMessage(chat, message, MarkdownV2)
+                } ?: chat.title
+                is GroupChat -> bot.getChat(chat).inviteLink ?.let {
+                    chat.title.linkMarkdownV2(it)
+                } ?: chat.title
+                else -> "Unknown :(".escapeMarkdownV2Common()
             }
-        }.launchIn(scope)
+            reply(
-    }
+                message,
-
+                answerText,
-    scope.coroutineContext[Job]!!.join()
+                MarkdownV2
-}
+            )
+        }
+    }.second.join()
+}

gradle.properties

@@ -1,5 +1,5 @@
 kotlin.code.style=official
 org.gradle.parallel=true
 
-kotlin_version=1.4.32
+kotlin_version=1.5.20
-telegram_bot_api_version=0.34.1
+telegram_bot_api_version=0.35.1