migration onto kotlin 2.1.20 and ktgbotapi 24.0.2

BusinessConnectionsBot/src/main/kotlin/BusinessConnectionsBot.kt

@@ -2,69 +2,24 @@ import dev.inmo.kslog.common.KSLog
 import dev.inmo.kslog.common.LogLevel
 import dev.inmo.kslog.common.defaultMessageFormatter
 import dev.inmo.kslog.common.setDefaultKSLog
-import dev.inmo.micro_utils.common.Percentage
-import dev.inmo.tgbotapi.extensions.api.answers.answer
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
-import dev.inmo.tgbotapi.extensions.api.business.getBusinessAccountStarBalance
-import dev.inmo.tgbotapi.extensions.api.business.deleteBusinessMessages
-import dev.inmo.tgbotapi.extensions.api.business.getBusinessAccountGifts
-import dev.inmo.tgbotapi.extensions.api.business.getBusinessAccountGiftsFlow
-import dev.inmo.tgbotapi.extensions.api.business.readBusinessMessage
-import dev.inmo.tgbotapi.extensions.api.business.removeBusinessAccountProfilePhoto
-import dev.inmo.tgbotapi.extensions.api.business.setBusinessAccountBio
-import dev.inmo.tgbotapi.extensions.api.business.setBusinessAccountName
-import dev.inmo.tgbotapi.extensions.api.business.setBusinessAccountProfilePhoto
-import dev.inmo.tgbotapi.extensions.api.business.setBusinessAccountUsername
-import dev.inmo.tgbotapi.extensions.api.business.transferBusinessAccountStars
-import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
 import dev.inmo.tgbotapi.extensions.api.chat.modify.pinChatMessage
 import dev.inmo.tgbotapi.extensions.api.chat.modify.unpinChatMessage
-import dev.inmo.tgbotapi.extensions.api.files.downloadFileToTemp
 import dev.inmo.tgbotapi.extensions.api.get.getBusinessConnection
 import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.api.send.send
-import dev.inmo.tgbotapi.extensions.api.stories.deleteStory
-import dev.inmo.tgbotapi.extensions.api.stories.postStory
 import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
-import dev.inmo.tgbotapi.extensions.utils.commonMessageOrNull
-import dev.inmo.tgbotapi.extensions.utils.extendedPrivateChatOrThrow
+import dev.inmo.tgbotapi.extensions.utils.accessibleMessageOrNull
 import dev.inmo.tgbotapi.extensions.utils.ifAccessibleMessage
 import dev.inmo.tgbotapi.extensions.utils.ifBusinessContentMessage
 import dev.inmo.tgbotapi.extensions.utils.textContentOrNull
-import dev.inmo.tgbotapi.extensions.utils.types.buttons.dataButton
-import dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard
-import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.flushAccumulatedUpdates
-import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
-import dev.inmo.tgbotapi.requests.abstracts.multipartFile
-import dev.inmo.tgbotapi.requests.business_connection.InputProfilePhoto
-import dev.inmo.tgbotapi.requests.stories.PostStory
 import dev.inmo.tgbotapi.types.ChatId
-import dev.inmo.tgbotapi.types.MessageId
-import dev.inmo.tgbotapi.types.RawChatId
 import dev.inmo.tgbotapi.types.business_connection.BusinessConnectionId
-import dev.inmo.tgbotapi.types.chat.PrivateChat
-import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
-import dev.inmo.tgbotapi.types.message.content.PhotoContent
-import dev.inmo.tgbotapi.types.message.content.StoryContent
-import dev.inmo.tgbotapi.types.message.content.TextContent
-import dev.inmo.tgbotapi.types.message.content.VideoContent
-import dev.inmo.tgbotapi.types.message.content.VisualMediaGroupPartContent
-import dev.inmo.tgbotapi.types.stories.InputStoryContent
-import dev.inmo.tgbotapi.types.stories.StoryArea
-import dev.inmo.tgbotapi.types.stories.StoryAreaPosition
-import dev.inmo.tgbotapi.types.stories.StoryAreaType
-import dev.inmo.tgbotapi.utils.botCommand
-import dev.inmo.tgbotapi.utils.code
-import dev.inmo.tgbotapi.utils.extensions.splitForText
-import dev.inmo.tgbotapi.utils.row
-import korlibs.time.seconds
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
-import kotlinx.serialization.json.Json
 
 suspend fun main(args: Array<String>) {
     val botToken = args.first()
@@ -79,25 +34,21 @@ suspend fun main(args: Array<String>) {
     }
 
     val businessConnectionsChats = mutableMapOf<BusinessConnectionId, ChatId>()
-    val chatsBusinessConnections = mutableMapOf<ChatId, BusinessConnectionId>()
     val businessConnectionsChatsMutex = Mutex()
 
     telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO)) {
         val me = getMe()
         println(me)
-        flushAccumulatedUpdates()
 
         onBusinessConnectionEnabled {
             businessConnectionsChatsMutex.withLock {
                 businessConnectionsChats[it.id] = it.userChatId
-                chatsBusinessConnections[it.userChatId] = it.id
             }
             send(it.userChatId, "Business connection ${it.businessConnectionId.string} has been enabled")
         }
         onBusinessConnectionDisabled {
             businessConnectionsChatsMutex.withLock {
                 businessConnectionsChats.remove(it.id)
-                chatsBusinessConnections.remove(it.userChatId)
             }
             send(it.userChatId, "Business connection ${it.businessConnectionId.string} has been disabled")
         }
@@ -120,20 +71,7 @@ suspend fun main(args: Array<String>) {
                 if (businessContentMessage.sentByBusinessConnectionOwner) {
                     reply(sent, "You have sent this message to the ${businessContentMessage.businessConnectionId.string} related chat")
                 } else {
-                    reply(
-                        to = sent,
-                        text = "User have sent this message to you in the ${businessContentMessage.businessConnectionId.string} related chat",
-                    )
-                    send(
-                        chatId = businessConnectionsChats[it.businessConnectionId] ?: return@ifBusinessContentMessage,
-                        text = "User have sent this message to you in the ${businessContentMessage.businessConnectionId.string} related chat",
-                        replyMarkup = inlineKeyboard {
-                            row {
-                                dataButton("Read message", "read ${it.chat.id.chatId.long} ${it.messageId.long}")
-                                dataButton("Delete message", "delete ${it.chat.id.chatId.long} ${it.messageId.long}")
-                            }
-                        }
-                    )
+                    reply(sent, "User have sent this message to you in the ${businessContentMessage.businessConnectionId.string} related chat")
                 }
             }
         }
@@ -160,328 +98,5 @@ suspend fun main(args: Array<String>) {
             }
             send(businessConnectionOwnerChat, "There are several removed messages in chat ${it.chat.id}: ${it.messageIds}")
         }
-        onCommand("get_business_account_info", initialFilter = { it.chat is PrivateChat }) {
-            val businessConnectionId = chatsBusinessConnections[it.chat.id]
-            val businessConnectionInfo = businessConnectionId ?.let { getBusinessConnection(it) }
-            reply(it) {
-                if (businessConnectionInfo == null) {
-                    +"There is no business connection for current chat"
-                } else {
-                    +(Json { prettyPrint = true; encodeDefaults = true }.encodeToString(businessConnectionInfo))
-                }
-            }
-        }
-        onMessageDataCallbackQuery(Regex("read \\d+ \\d+")) {
-            val (_, chatIdString, messageIdString) = it.data.split(" ")
-            val chatId = chatIdString.toLongOrNull() ?.let(::RawChatId) ?.let(::ChatId) ?: return@onMessageDataCallbackQuery
-            val messageId = messageIdString.toLongOrNull() ?.let(::MessageId) ?: return@onMessageDataCallbackQuery
-            val businessConnectionId = chatsBusinessConnections[it.message.chat.id]
-
-            val readResponse = businessConnectionId ?.let { readBusinessMessage(it, chatId, messageId) }
-            answer(
-                it,
-                if (readResponse == null) {
-                    "There is no business connection for current chat"
-                } else {
-                    "Message has been read"
-                }
-            )
-        }
-        onMessageDataCallbackQuery(Regex("delete \\d+ \\d+")) {
-            val (_, chatIdString, messageIdString) = it.data.split(" ")
-            val chatId = chatIdString.toLongOrNull() ?.let(::RawChatId) ?.let(::ChatId) ?: return@onMessageDataCallbackQuery
-            val messageId = messageIdString.toLongOrNull() ?.let(::MessageId) ?: return@onMessageDataCallbackQuery
-            val businessConnectionId = chatsBusinessConnections[it.message.chat.id]
-
-            val readResponse = businessConnectionId ?.let { deleteBusinessMessages(it, listOf(messageId)) }
-            answer(
-                it,
-                if (readResponse == null) {
-                    "There is no business connection for current chat"
-                } else {
-                    "Message has been deleted"
-                }
-            )
-        }
-        onCommandWithArgs("set_business_account_name", initialFilter = { it.chat is PrivateChat }) { it, args ->
-            val firstName = args[0]
-            val secondName = args.getOrNull(1)
-            val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@onCommandWithArgs
-            val set = runCatching {
-                setBusinessAccountName(
-                    businessConnectionId,
-                    firstName,
-                    secondName
-                )
-            }.getOrElse { false }
-            reply(it) {
-                if (set) {
-                    +"Account name has been set"
-                } else {
-                    +"Account name has not been set"
-                }
-            }
-        }
-        onCommandWithArgs("set_business_account_username", initialFilter = { it.chat is PrivateChat }) { it, args ->
-            val username = args[0]
-            val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@onCommandWithArgs
-            val set = runCatching {
-                setBusinessAccountUsername(
-                    businessConnectionId,
-                    username
-                )
-            }.getOrElse {
-                it.printStackTrace()
-                false
-            }
-            reply(it) {
-                if (set) {
-                    +"Account username has been set"
-                } else {
-                    +"Account username has not been set"
-                }
-            }
-        }
-        onCommand("get_business_account_star_balance", initialFilter = { it.chat is PrivateChat }) {
-            val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@onCommand
-            val starAmount = runCatching {
-                getBusinessAccountStarBalance(businessConnectionId)
-            }.getOrElse {
-                it.printStackTrace()
-                null
-            }
-            reply(it) {
-                if (starAmount != null) {
-                    +"Account stars amount: $starAmount"
-                } else {
-                    +"Account stars amount has not been got"
-                }
-            }
-        }
-        onCommandWithArgs("transfer_business_account_stars", initialFilter = { it.chat is PrivateChat }) { it, args ->
-            val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@onCommandWithArgs
-            val count = args.firstOrNull() ?.toIntOrNull() ?: reply(it) {
-                "Pass amount of stars to transfer to bot with command"
-            }.let {
-                return@onCommandWithArgs
-            }
-            val transferred = runCatching {
-                transferBusinessAccountStars(businessConnectionId, count)
-            }.getOrElse {
-                it.printStackTrace()
-                false
-            }
-            reply(it) {
-                if (transferred) {
-                    +"Stars have been transferred"
-                } else {
-                    +"Stars have not been transferred"
-                }
-            }
-        }
-        onCommand("get_business_account_gifts", initialFilter = { it.chat is PrivateChat }) {
-            val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@onCommand
-            val giftsFlow = runCatching {
-                getBusinessAccountGiftsFlow(businessConnectionId)
-            }.getOrElse {
-                it.printStackTrace()
-                null
-            }
-            if (giftsFlow == null) {
-                reply(it) {
-                    +"Error in receiving of gifts"
-                }
-            } else {
-                giftsFlow.collect { giftsPage ->
-                    giftsPage.gifts.joinToString {
-                        it.toString()
-                    }.splitForText().forEach { message ->
-                        reply(it, message)
-                    }
-                }
-            }
-        }
-        onCommand("set_business_account_bio", requireOnlyCommandInMessage = false, initialFilter = { it.chat is PrivateChat }) {
-            val initialBio = getChat(it.chat).extendedPrivateChatOrThrow().bio
-            val bio = it.content.text.removePrefix("/set_business_account_bio").trim()
-            val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@onCommand
-            val set = runCatching {
-                setBusinessAccountBio(
-                    businessConnectionId,
-                    bio
-                )
-            }.getOrElse {
-                it.printStackTrace()
-                false
-            }
-            reply(it) {
-                if (set) {
-                    +"Account bio has been set. It will be reset within 15 seconds.\n\nInitial bio: " + code(initialBio)
-                } else {
-                    +"Account bio has not been set"
-                }
-            }
-            delay(15.seconds)
-            val reset = runCatching {
-                setBusinessAccountBio(
-                    businessConnectionId,
-                    initialBio
-                )
-            }.getOrElse {
-                it.printStackTrace()
-                false
-            }
-            reply(it) {
-                if (reset) {
-                    +"Account bio has been reset"
-                } else {
-                    +"Account bio has not been set. Set it manually: " + code(initialBio)
-                }
-            }
-        }
-        suspend fun handleSetProfilePhoto(it: CommonMessage<TextContent>, isPublic: Boolean) {
-            val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@handleSetProfilePhoto
-            val replyTo = it.replyTo ?.commonMessageOrNull() ?.withContentOrNull<PhotoContent>()
-            if (replyTo == null) {
-                reply(it) {
-                    +"Reply to photo for using of this command"
-                }
-                return@handleSetProfilePhoto
-            }
-
-            val set = runCatching {
-                val file = downloadFileToTemp(replyTo.content)
-                setBusinessAccountProfilePhoto(
-                    businessConnectionId,
-                    InputProfilePhoto.Static(
-                        file.multipartFile()
-                    ),
-                    isPublic = isPublic
-                )
-            }.getOrElse {
-                it.printStackTrace()
-                false
-            }
-            reply(it) {
-                if (set) {
-                    +"Account profile photo has been set. It will be reset within 15 seconds"
-                } else {
-                    +"Account profile photo has not been set"
-                }
-            }
-            if (set == false) { return@handleSetProfilePhoto }
-            delay(15.seconds)
-            val reset = runCatching {
-                removeBusinessAccountProfilePhoto(
-                    businessConnectionId,
-                    isPublic = isPublic
-                )
-            }.getOrElse {
-                it.printStackTrace()
-                false
-            }
-            reply(it) {
-                if (reset) {
-                    +"Account profile photo has been reset"
-                } else {
-                    +"Account profile photo has not been set. Set it manually"
-                }
-            }
-        }
-        onCommand("set_business_account_profile_photo", initialFilter = { it.chat is PrivateChat }) {
-            handleSetProfilePhoto(it, false)
-        }
-        onCommand("set_business_account_profile_photo_public", initialFilter = { it.chat is PrivateChat }) {
-            handleSetProfilePhoto(it, true)
-        }
-
-        onCommand("post_story", initialFilter = { it.chat is PrivateChat }) {
-            val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@onCommand
-            val replyTo = it.replyTo ?.commonMessageOrNull() ?.withContentOrNull<VisualMediaGroupPartContent>()
-            if (replyTo == null) {
-                reply(it) {
-                    +"Reply to photo or video for using of this command"
-                }
-                return@onCommand
-            }
-
-            val posted = runCatching {
-                val file = downloadFileToTemp(replyTo.content)
-                postStory(
-                    businessConnectionId,
-                    when (replyTo.content) {
-                        is PhotoContent -> InputStoryContent.Photo(
-                            file.multipartFile()
-                        )
-                        is VideoContent -> InputStoryContent.Video(
-                            file.multipartFile()
-                        )
-                    },
-                    activePeriod = PostStory.ACTIVE_PERIOD_6_HOURS,
-                    areas = listOf(
-                        StoryArea(
-                            StoryAreaPosition(
-                                x = Percentage.of100(50.0),
-                                y = Percentage.of100(50.0),
-                                width = Percentage.of100(8.0),
-                                height = Percentage.of100(8.0),
-                                rotationAngle = 45.0,
-                                cornerRadius = Percentage.of100(4.0),
-                            ),
-                            StoryAreaType.Link(
-                                "https://github.com/InsanusMokrassar/TelegramBotAPI-examples/blob/master/BusinessConnectionsBot/src/main/kotlin/BusinessConnectionsBot.kt"
-                            )
-                        )
-                    )
-                ) {
-                    +"It is test of postStory :)"
-                }
-            }.getOrElse {
-                it.printStackTrace()
-                null
-            }
-            reply(it) {
-                if (posted != null) {
-                    +"Story has been posted. You may unpost it with " + botCommand("remove_story")
-                } else {
-                    +"Story has not been posted"
-                }
-            }
-        }
-
-        onCommand("delete_story", initialFilter = { it.chat is PrivateChat }) {
-            val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@onCommand
-            val replyTo = it.replyTo ?.commonMessageOrNull() ?.withContentOrNull<StoryContent>()
-            if (replyTo == null) {
-                reply(it) {
-                    +"Reply to photo or video for using of this command"
-                }
-                return@onCommand
-            }
-
-            val deleted = runCatching {
-                deleteStory(businessConnectionId, replyTo.content.story.id)
-            }.getOrElse {
-                it.printStackTrace()
-                false
-            }
-            reply(it) {
-                if (deleted) {
-                    +"Story has been deleted"
-                } else {
-                    +"Story has not been deleted"
-                }
-            }
-        }
-
-        // Will work when some premium user sending to some other user checklist
-        onChecklistContent {
-            execute(
-                it.content.createResend(
-                    it.chat.id,
-                    businessConnectionId = it.chat.id.businessConnectionId ?: chatsBusinessConnections[it.chat.id] ?: return@onChecklistContent
-                )
-            )
-        }
     }.second.join()
 }

ChecklistsBot/build.gradle

@@ -1,21 +0,0 @@
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-apply plugin: 'kotlin'
-apply plugin: 'application'
-
-mainClassName="ChecklistsBotKt"
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-}

ChecklistsBot/src/main/kotlin/ChecklistsBot.kt

@@ -1,120 +0,0 @@
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.LogLevel
-import dev.inmo.kslog.common.defaultMessageFormatter
-import dev.inmo.kslog.common.setDefaultKSLog
-import dev.inmo.micro_utils.coroutines.runCatchingLogging
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-import dev.inmo.tgbotapi.extensions.api.bot.getMe
-import dev.inmo.tgbotapi.extensions.api.bot.getMyStarBalance
-import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
-import dev.inmo.tgbotapi.extensions.api.send.reply
-import dev.inmo.tgbotapi.extensions.api.send.resend
-import dev.inmo.tgbotapi.extensions.api.send.send
-import dev.inmo.tgbotapi.extensions.api.suggested.approveSuggestedPost
-import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContextData
-import dev.inmo.tgbotapi.extensions.behaviour_builder.buildSubcontextInitialAction
-import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitSuggestedPostApproved
-import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitSuggestedPostDeclined
-import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChannelDirectMessagesConfigurationChanged
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChecklistContent
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChecklistTasksAdded
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChecklistTasksDone
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSuggestedPostApprovalFailed
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSuggestedPostApproved
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSuggestedPostDeclined
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSuggestedPostPaid
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSuggestedPostRefunded
-import dev.inmo.tgbotapi.extensions.utils.channelDirectMessagesContentMessageOrNull
-import dev.inmo.tgbotapi.extensions.utils.previewChannelDirectMessagesChatOrNull
-import dev.inmo.tgbotapi.extensions.utils.suggestedChannelDirectMessagesContentMessageOrNull
-import dev.inmo.tgbotapi.types.checklists.ChecklistTaskId
-import dev.inmo.tgbotapi.types.message.SuggestedPostParameters
-import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
-import dev.inmo.tgbotapi.types.message.content.ChecklistContent
-import dev.inmo.tgbotapi.types.message.textsources.TextSourcesList
-import dev.inmo.tgbotapi.types.update.abstracts.Update
-import dev.inmo.tgbotapi.utils.bold
-import dev.inmo.tgbotapi.utils.buildEntities
-import dev.inmo.tgbotapi.utils.code
-import dev.inmo.tgbotapi.utils.firstOf
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.filter
-import kotlinx.coroutines.flow.first
-
-suspend fun main(vararg args: String) {
-    val botToken = args.first()
-
-    val isDebug = args.any { it == "debug" }
-    val isTestServer = args.any { it == "testServer" }
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
-
-    telegramBotWithBehaviourAndLongPolling(
-        botToken,
-        CoroutineScope(Dispatchers.Default),
-        testServer = isTestServer,
-    ) {
-        // start here!!
-        val me = getMe()
-        println(me)
-
-        fun ChecklistContent.textBuilderTextSources(): TextSourcesList {
-            return buildEntities {
-                +checklist.textSources + "\n\n"
-                checklist.tasks.forEach { task ->
-                    +"• "
-                    code(
-                        if (task.completionDate != null) {
-                            "[x] "
-                        } else {
-                            "[ ] "
-                        }
-                    )
-
-                    bold(task.textSources) + "\n"
-                }
-            }
-        }
-
-        onChecklistContent { messageWithContent ->
-            reply(messageWithContent) {
-                +messageWithContent.content.textBuilderTextSources()
-            }
-        }
-
-        onChecklistTasksDone { eventMessage ->
-            reply(
-                eventMessage,
-                checklistTaskId = eventMessage.chatEvent.markedAsDone ?.firstOrNull()
-            ) {
-                eventMessage.chatEvent.checklistMessage.content.checklist
-                +eventMessage.chatEvent.checklistMessage.content.textBuilderTextSources()
-            }
-        }
-
-        onChecklistTasksAdded { messageWithContent ->
-            reply(
-                messageWithContent.chatEvent.checklistMessage,
-                checklistTaskId = messageWithContent.chatEvent.tasks.firstOrNull() ?.id
-            ) {
-                +messageWithContent.chatEvent.checklistMessage.content.textBuilderTextSources()
-            }
-        }
-
-        allUpdatesFlow.subscribeLoggingDropExceptions(this) {
-            println(it)
-        }
-    }.second.join()
-}

CustomBot/src/main/kotlin/CustomBot.kt

@@ -4,24 +4,10 @@ import dev.inmo.kslog.common.defaultMessageFormatter
 import dev.inmo.kslog.common.setDefaultKSLog
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
-import dev.inmo.tgbotapi.extensions.api.bot.getMyStarBalance
-import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
-import dev.inmo.tgbotapi.extensions.api.get.getUserProfileAudios
-import dev.inmo.tgbotapi.extensions.api.send.media.sendPaidMedia
-import dev.inmo.tgbotapi.extensions.api.send.reply
-import dev.inmo.tgbotapi.extensions.api.send.replyWithAudio
-import dev.inmo.tgbotapi.extensions.api.send.replyWithPlaylist
 import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContextData
 import dev.inmo.tgbotapi.extensions.behaviour_builder.buildSubcontextInitialAction
 import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChannelDirectMessagesConfigurationChanged
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatOwnerChanged
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatOwnerLeft
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onPhoto
-import dev.inmo.tgbotapi.types.media.AudioMediaGroupMemberTelegramMedia
-import dev.inmo.tgbotapi.types.media.toTelegramMediaAudio
-import dev.inmo.tgbotapi.types.media.toTelegramPaidMediaPhoto
 import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
 import dev.inmo.tgbotapi.types.update.abstracts.Update
 import kotlinx.coroutines.CoroutineScope
@@ -79,33 +65,6 @@ suspend fun main(vararg args: String) {
         onCommand("start") {
             println(data.update)
             println(data.commonMessage)
-            println(getChat(it.chat))
-            var currentOffset = 0
-            val pageSize = 2
-            do {
-                val userAudios = getUserProfileAudios(userId = it.chat.id, offset = currentOffset, limit = pageSize)
-                currentOffset += pageSize
-                println(userAudios)
-                when (userAudios.audios.size) {
-                    1 -> {
-                        replyWithAudio(
-                            it,
-                            userAudios.audios.first().fileId
-                        )
-                    }
-                    0 -> {
-                        // do nothing
-                    }
-                    else -> {
-                        replyWithPlaylist(
-                            it,
-                            userAudios.audios.map {
-                                it.toTelegramMediaAudio()
-                            }
-                        )
-                    }
-                }
-            } while (currentOffset < userAudios.totalCount && userAudios.audios.isNotEmpty())
         }
 
         onCommand(
@@ -118,17 +77,6 @@ suspend fun main(vararg args: String) {
             println(data.commonMessage)
         }
 
-        onCommand("getMyStarBalance") {
-            reply(
-                to = it,
-                text = getMyStarBalance().toString()
-            )
-        }
-
-        onChannelDirectMessagesConfigurationChanged {
-            println(it.chatEvent)
-        }
-
         allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
             println(it)
         }

DraftsBot/README.md

@@ -1,9 +0,0 @@
-# Drafts bot
-
-The main purpose of this bot is just to answer "Oh, hi, " and add user mention here
-
-## Launch
-
-```bash
-../gradlew run --args="BOT_TOKEN"
-```

DraftsBot/build.gradle

@@ -1,21 +0,0 @@
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-apply plugin: 'kotlin'
-apply plugin: 'application'
-
-mainClassName="TopicsHandlingKt"
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-}

DraftsBot/src/main/kotlin/DraftsBot.kt

@@ -1,86 +0,0 @@
-import com.benasher44.uuid.uuid4
-import dev.inmo.kslog.common.w
-import dev.inmo.micro_utils.coroutines.runCatchingLogging
-import dev.inmo.micro_utils.coroutines.runCatchingSafely
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-import dev.inmo.tgbotapi.bot.TelegramBot
-import dev.inmo.tgbotapi.extensions.api.bot.getMe
-import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
-import dev.inmo.tgbotapi.extensions.api.chat.forum.*
-import dev.inmo.tgbotapi.extensions.api.send.reply
-import dev.inmo.tgbotapi.extensions.api.send.send
-import dev.inmo.tgbotapi.extensions.api.send.sendMessageDraftFlow
-import dev.inmo.tgbotapi.extensions.api.send.sendMessageDraftFlowWithTexts
-import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onForumTopicClosed
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onForumTopicCreated
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onForumTopicEdited
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onForumTopicReopened
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onGeneralForumTopicHidden
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onGeneralForumTopicUnhidden
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onPrivateForumTopicCreated
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onPrivateForumTopicEdited
-import dev.inmo.tgbotapi.extensions.utils.forumChatOrNull
-import dev.inmo.tgbotapi.extensions.utils.forumContentMessageOrNull
-import dev.inmo.tgbotapi.extensions.utils.privateChatOrNull
-import dev.inmo.tgbotapi.extensions.utils.privateForumChatOrNull
-import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.flushAccumulatedUpdates
-import dev.inmo.tgbotapi.types.BotCommand
-import dev.inmo.tgbotapi.types.ForumTopic
-import dev.inmo.tgbotapi.types.chat.PrivateChat
-import dev.inmo.tgbotapi.types.commands.BotCommandScope
-import io.ktor.client.plugins.*
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.flow
-import kotlinx.coroutines.isActive
-
-const val testText = """
-    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.    
-"""
-
-suspend fun main(vararg args: String) {
-    telegramBotWithBehaviourAndLongPolling(
-        args.first(),
-        CoroutineScope(Dispatchers.Default),
-        defaultExceptionsHandler = {
-            it.printStackTrace()
-        },
-        builder = {
-            client = client.config {
-                install(HttpTimeout) {
-                    requestTimeoutMillis = 30000
-                    socketTimeoutMillis = 30000
-                    connectTimeoutMillis = 30000
-                }
-            }
-        }
-    ) {
-        onCommand("test_draft_flow") {
-            sendMessageDraftFlowWithTexts(
-                it.chat.id,
-                flow<String> {
-                    val step = 50
-                    var currentLength = step
-                    while (isActive && testText.length > currentLength) {
-                        delay(500L)
-                        emit(testText.take(currentLength))
-                        currentLength += step
-                    }
-                },
-            )
-            send(it.chat, testText)
-        }
-
-        setMyCommands(
-            BotCommand("test_draft_flow", "Start draft testing with flow"),
-            scope = BotCommandScope.AllGroupChats
-        )
-        allUpdatesFlow.subscribeLoggingDropExceptions(this) {
-            println(it)
-        }
-    }.second.join()
-}

FSMBot/src/main/kotlin/SimpleFSMBot.kt

@@ -1,13 +1,10 @@
-import dev.inmo.micro_utils.coroutines.awaitFirst
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.micro_utils.fsm.common.State
 import dev.inmo.tgbotapi.extensions.api.send.send
 import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitAnyContentMessage
-import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitCommandMessage
 import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndFSMAndStartLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.command
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
-import dev.inmo.tgbotapi.extensions.behaviour_builder.utils.containsCommand
 import dev.inmo.tgbotapi.extensions.utils.extensions.parseCommandsWithArgs
 import dev.inmo.tgbotapi.extensions.utils.extensions.sameThread
 import dev.inmo.tgbotapi.extensions.utils.textContentOrNull
@@ -16,12 +13,10 @@ import dev.inmo.tgbotapi.types.IdChatIdentifier
 import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
 import dev.inmo.tgbotapi.types.message.content.TextContent
 import dev.inmo.tgbotapi.utils.botCommand
-import dev.inmo.tgbotapi.utils.firstOf
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.map
 
 sealed interface BotState : State
 data class ExpectContentOrStopState(override val context: IdChatIdentifier, val sourceMessage: CommonMessage<TextContent>) : BotState
@@ -53,29 +48,19 @@ suspend fun main(args: Array<String>) {
                 +"Send me some content or " + botCommand("stop") + " if you want to stop sending"
             }
 
-            val contentMessage = firstOf(
-                {
-                    waitCommandMessage("stop").filter { message ->
-                        message.sameThread(it.sourceMessage)
-                    }.first()
-                    null
-                },
-                {
-                    waitAnyContentMessage().filter { message ->
-                        message.sameThread(it.sourceMessage)
-                    }.filter {
-                        containsCommand(
-                            "stop",
-                            it.withContentOrNull<TextContent>() ?.content ?.textSources ?: return@filter false
-                        ) == false
-                    }.first()
-                }
-            ) ?: return@strictlyOn StopState(it.context)
-
+            val contentMessage = waitAnyContentMessage().filter { message ->
+                message.sameThread(it.sourceMessage)
+            }.first()
             val content = contentMessage.content
 
-            execute(content.createResend(it.context))
-            it
+            when {
+                content is TextContent && content.text == "/stop"
+                || content is TextContent && content.parseCommandsWithArgs().keys.contains("stop") -> StopState(it.context)
+                else -> {
+                    execute(content.createResend(it.context))
+                    it
+                }
+            }
         }
         strictlyOn<StopState> {
             send(it.context) { +"You have stopped sending of content" }

GetMeBot/src/main/kotlin/GetMeBot.kt

@@ -0,0 +1,29 @@
+import dev.inmo.kslog.common.KSLog
+import dev.inmo.kslog.common.LogLevel
+import dev.inmo.kslog.common.defaultMessageFormatter
+import dev.inmo.kslog.common.setDefaultKSLog
+import dev.inmo.tgbotapi.bot.ktor.telegramBot
+import dev.inmo.tgbotapi.extensions.api.bot.getMe
+import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
+
+/**
+ * This is one of the easiest bots - it will just print information about itself
+ */
+suspend fun main(vararg args: String) {
+    val botToken = args.first()
+    val isDebug = args.getOrNull(1) == "debug"
+
+    if (isDebug) {
+        setDefaultKSLog(
+            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
+                println(defaultMessageFormatter(level, tag, message, throwable))
+            }
+        )
+    }
+
+    val bot = telegramBot(botToken)
+
+    val me = bot.getMe()
+    println(me)
+    println(bot.getChat(me))
+}

GiftsBot/build.gradle

@@ -1,21 +0,0 @@
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-apply plugin: 'kotlin'
-apply plugin: 'application'
-
-mainClassName="GiftsBotKt"
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-}

GiftsBot/src/main/kotlin/GiftsBot.kt

@@ -1,112 +0,0 @@
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.LogLevel
-import dev.inmo.kslog.common.defaultMessageFormatter
-import dev.inmo.kslog.common.setDefaultKSLog
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-import dev.inmo.tgbotapi.extensions.api.bot.getMe
-import dev.inmo.tgbotapi.extensions.api.business.getBusinessAccountGiftsFlow
-import dev.inmo.tgbotapi.extensions.api.gifts.getChatGiftsFlow
-import dev.inmo.tgbotapi.extensions.api.gifts.getUserGiftsFlow
-import dev.inmo.tgbotapi.extensions.api.send.reply
-import dev.inmo.tgbotapi.extensions.api.send.withTypingAction
-import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onGiveawayCompleted
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onGiveawayContent
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onGiveawayCreated
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onGiveawayWinners
-import dev.inmo.tgbotapi.types.chat.BusinessChat
-import dev.inmo.tgbotapi.types.chat.PrivateChat
-import dev.inmo.tgbotapi.types.chat.PublicChat
-import dev.inmo.tgbotapi.types.chat.UnknownChatType
-import dev.inmo.tgbotapi.types.gifts.OwnedGift
-import dev.inmo.tgbotapi.types.message.textsources.splitForText
-import dev.inmo.tgbotapi.utils.bold
-import dev.inmo.tgbotapi.utils.buildEntities
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-
-suspend fun main(vararg args: String) {
-    val botToken = args.first()
-
-    val isDebug = args.any { it == "debug" }
-    val isTestServer = args.any { it == "testServer" }
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
-
-    telegramBotWithBehaviourAndLongPolling(botToken, testServer = isTestServer) {
-        // start here!!
-        val me = getMe()
-        println(me)
-
-        onCommand("start") {
-            val giftsFlow = when (val chat = it.chat) {
-                is BusinessChat -> {
-                    getBusinessAccountGiftsFlow(
-                        chat.id.businessConnectionId
-                    )
-                }
-                is PrivateChat -> {
-                    getUserGiftsFlow(it.chat.id)
-                }
-                is UnknownChatType,
-                is PublicChat -> {
-                    getChatGiftsFlow(it.chat.id)
-                }
-            }
-
-            withTypingAction(it.chat) {
-                val texts = buildEntities {
-                    giftsFlow.collect { ownedGifts ->
-                        ownedGifts.gifts.forEach {
-                            when (it) {
-                                is OwnedGift.Regular.Common -> {
-                                    bold("Type") + ": Regular common\n"
-                                    bold("Id") + ": ${it.gift.id.string}\n"
-                                    bold("Text") + ": ${it.text ?: "(None)"}\n"
-                                    bold("Stars cost") + ": ${it.gift.starCount}\n"
-                                }
-                                is OwnedGift.Unique.Common -> {
-                                    bold("Type") + ": Unique common\n"
-                                    bold("Id") + ": ${it.gift.id ?.string ?: "(None)"}\n"
-                                    bold("Name") + ": ${it.gift.name.value}\n"
-                                    bold("Model") + ": ${it.gift.model.name}\n"
-                                    bold("Number") + ": ${it.gift.number}\n"
-                                }
-                                is OwnedGift.Regular.OwnedByBusinessAccount -> {
-                                    bold("Type") + ": Regular owned by business\n"
-                                    bold("Id") + ": ${it.gift.id.string}\n"
-                                    bold("Text") + ": ${it.text ?: "(None)"}\n"
-                                    bold("Stars cost") + ": ${it.gift.starCount}\n"
-                                }
-                                is OwnedGift.Unique.OwnedByBusinessAccount -> {
-                                    bold("Type") + ": Unique owned by business\n"
-                                    bold("Id") + ": ${it.gift.id ?.string ?: "(None)"}\n"
-                                    bold("Name") + ": ${it.gift.name.value}\n"
-                                    bold("Model") + ": ${it.gift.model.name}\n"
-                                    bold("Number") + ": ${it.gift.number}\n"
-                                }
-                            }
-                        }
-                    }
-                }
-                val preparedTexts = texts.splitForText()
-                if (preparedTexts.isEmpty()) {
-                    reply(it, "This chat have no any gifts")
-                } else {
-                    preparedTexts.forEach { preparedText -> reply(it, preparedText) }
-                }
-            }
-        }
-
-//        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
-//            println(it)
-//        }
-    }.second.join()
-}

InlineQueriesBot/build.gradle

@@ -29,7 +29,12 @@ kotlin {
                 implementation kotlin('stdlib')
 
                 api "dev.inmo:tgbotapi:$telegram_bot_api_version"
-                api "io.ktor:ktor-client-logging:$ktor_version"
+                api "dev.inmo:tgbotapi:$telegram_bot_api_version"
+            }
+        }
+        jvmMain {
+            dependencies {
+                api "io.ktor:ktor-client-logging-jvm:$ktor_version"
             }
         }
     }

InlineQueriesBot/src/commonMain/kotlin/Bot.kt

@@ -1,4 +1,4 @@
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.answers.answer
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.send.reply
@@ -59,7 +59,7 @@ suspend fun doInlineQueriesBot(token: String) {
             reply(message, deepLink)
         }
 
-        allUpdatesFlow.subscribeLoggingDropExceptions(scope = this) {
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
             println(it)
         }
 

KeyboardsBot/KeyboardsBotLib/src/commonMain/kotlin/KeyboardsBot.kt

@@ -1,4 +1,4 @@
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.bot.ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.answers.answer
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
@@ -11,11 +11,9 @@ import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
 import dev.inmo.tgbotapi.extensions.utils.types.buttons.*
 import dev.inmo.tgbotapi.extensions.utils.withContent
 import dev.inmo.tgbotapi.types.BotCommand
-import dev.inmo.tgbotapi.types.CustomEmojiId
 import dev.inmo.tgbotapi.types.InlineQueries.InlineQueryResult.InlineQueryResultArticle
 import dev.inmo.tgbotapi.types.InlineQueries.InputMessageContent.InputTextMessageContent
 import dev.inmo.tgbotapi.types.InlineQueryId
-import dev.inmo.tgbotapi.types.buttons.KeyboardButtonStyle
 import dev.inmo.tgbotapi.types.message.content.TextContent
 import dev.inmo.tgbotapi.utils.PreviewFeature
 import dev.inmo.tgbotapi.utils.botCommand
@@ -53,17 +51,17 @@ fun InlineKeyboardBuilder.includePageButtons(page: Int, count: Int) {
 
     row {
         if (page - 1 > 2) {
-            dataButton("<<", "1 $count", style = KeyboardButtonStyle.Danger)
+            dataButton("<<", "1 $count")
         }
         if (page - 1 > 1) {
-            dataButton("<", "${page - 2} $count", style = KeyboardButtonStyle.Primary)
+            dataButton("<", "${page - 2} $count")
         }
 
         if (page + 1 < count) {
-            dataButton(">", "${page + 2} $count", style = KeyboardButtonStyle.Success)
+            dataButton(">", "${page + 2} $count")
         }
         if (page + 2 < count) {
-            dataButton(">>", "$count $count", style = KeyboardButtonStyle.Danger)
+            dataButton(">>", "$count $count")
         }
     }
     row {
@@ -91,7 +89,7 @@ suspend fun activateKeyboardsBot(
         onCommandWithArgs("inline") { message, args ->
             val numberArgs = args.mapNotNull { it.toIntOrNull() }
             val numberOfPages = numberArgs.getOrNull(1) ?: numberArgs.firstOrNull() ?: 10
-            val page = numberArgs.firstOrNull()?.takeIf { numberArgs.size > 1 }?.coerceAtLeast(1) ?: 1
+            val page = numberArgs.firstOrNull() ?.takeIf { numberArgs.size > 1 } ?.coerceAtLeast(1) ?: 1
             reply(
                 message,
                 replyMarkup = inlineKeyboard {
@@ -140,8 +138,7 @@ suspend fun activateKeyboardsBot(
 
         onBaseInlineQuery {
             val page = it.query.takeWhile { it.isDigit() }.toIntOrNull() ?: return@onBaseInlineQuery
-            val count = it.query.removePrefix(page.toString()).dropWhile { !it.isDigit() }.takeWhile { it.isDigit() }
-                .toIntOrNull() ?: return@onBaseInlineQuery
+            val count = it.query.removePrefix(page.toString()).dropWhile { !it.isDigit() }.takeWhile { it.isDigit() }.toIntOrNull() ?: return@onBaseInlineQuery
 
             answer(
                 it,
@@ -163,7 +160,7 @@ suspend fun activateKeyboardsBot(
                 it,
                 replyMarkup = replyKeyboard(resizeKeyboard = true, oneTimeKeyboard = true) {
                     row {
-                        simpleButton("/inline", style = KeyboardButtonStyle.Primary)
+                        simpleButton("/inline")
                     }
                 }
             ) {
@@ -173,7 +170,7 @@ suspend fun activateKeyboardsBot(
 
         setMyCommands(BotCommand("inline", "Creates message with pagination inline keyboard"))
 
-        allUpdatesFlow.subscribeLoggingDropExceptions(scope = this) {
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
             println(it)
         }
     }.join()

MyBot/src/main/kotlin/MyBot.kt

@@ -1,94 +0,0 @@
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.LogLevel
-import dev.inmo.kslog.common.defaultMessageFormatter
-import dev.inmo.kslog.common.setDefaultKSLog
-import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions
-import dev.inmo.micro_utils.coroutines.runCatchingLogging
-import dev.inmo.tgbotapi.bot.ktor.telegramBot
-import dev.inmo.tgbotapi.extensions.api.bot.getMe
-import dev.inmo.tgbotapi.extensions.api.bot.removeMyProfilePhoto
-import dev.inmo.tgbotapi.extensions.api.bot.setMyProfilePhoto
-import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
-import dev.inmo.tgbotapi.extensions.api.files.downloadFileToTemp
-import dev.inmo.tgbotapi.extensions.api.send.reply
-import dev.inmo.tgbotapi.extensions.api.send.sendMessageDraftFlowWithTexts
-import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitPhotoMessage
-import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
-import dev.inmo.tgbotapi.extensions.utils.extensions.sameChat
-import dev.inmo.tgbotapi.requests.abstracts.asMultipartFile
-import dev.inmo.tgbotapi.requests.business_connection.InputProfilePhoto
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.consumeAsFlow
-import kotlinx.coroutines.flow.filter
-import kotlinx.coroutines.flow.first
-
-/**
- * This is one of the easiest bots - it will just print information about itself
- */
-suspend fun main(vararg args: String) {
-    val botToken = args.first()
-    val isDebug = args.any { it == "debug" }
-    val isTestServer = args.any { it == "testServer" }
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
-
-    val bot = telegramBot(botToken)
-
-    telegramBotWithBehaviourAndLongPolling(
-        botToken,
-        CoroutineScope(Dispatchers.Default),
-        testServer = isTestServer,
-    ) {
-        val me = bot.getMe()
-        println(me)
-        println(bot.getChat(me))
-
-        onCommand("setMyProfilePhoto") { commandMessage ->
-            reply(commandMessage, "ok, send me new photo")
-            val newPhotoMessage = waitPhotoMessage().filter { potentialPhotoMessage ->
-                potentialPhotoMessage.sameChat(commandMessage)
-            }.first()
-            val draftMessagesChannel = Channel<String>(capacity = 1)
-
-            launchLoggingDropExceptions {
-                sendMessageDraftFlowWithTexts(commandMessage.chat.id, draftMessagesChannel.consumeAsFlow())
-            }.invokeOnCompletion {
-                draftMessagesChannel.close(it)
-            }
-
-            draftMessagesChannel.send("Start downloading photo")
-            val photoFile = downloadFileToTemp(newPhotoMessage.content)
-
-            draftMessagesChannel.send("Photo file have been downloaded. Start set my profile photo")
-
-            val setResult = setMyProfilePhoto(
-                InputProfilePhoto.Static(
-                    photoFile.asMultipartFile()
-                )
-            )
-            if (setResult) {
-                reply(commandMessage, "New photo have been set")
-            }
-        }
-
-        onCommand("removeMyProfilePhoto") {
-            runCatchingLogging {
-                if (removeMyProfilePhoto()) {
-                    reply(it, "Photo have been removed")
-                }
-            }.onFailure { e ->
-                e.printStackTrace()
-                reply(it, "Something web wrong. See logs for details.")
-            }
-        }
-    }.second.join()
-}

ResenderBot/ResenderBotLib/src/commonMain/kotlin/ResenderBot.kt

@@ -1,7 +1,4 @@
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.defaultMessageFormatter
-import dev.inmo.kslog.common.filter.filtered
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.send.withTypingAction
 import dev.inmo.tgbotapi.extensions.behaviour_builder.filters.MessageFilterByChat
@@ -13,9 +10,7 @@ import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
 import dev.inmo.tgbotapi.types.ReplyParameters
 import dev.inmo.tgbotapi.types.message.abstracts.BusinessContentMessage
 import dev.inmo.tgbotapi.types.message.content.TextContent
-import dev.inmo.tgbotapi.utils.DefaultKTgBotAPIKSLog
 import dev.inmo.tgbotapi.utils.extensions.threadIdOrNull
-import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.currentCoroutineContext
@@ -24,10 +19,7 @@ suspend fun activateResenderBot(
     token: String,
     print: (Any) -> Unit
 ) {
-    telegramBotWithBehaviourAndLongPolling(
-        token,
-        scope = CoroutineScope(currentCoroutineContext() + SupervisorJob()),
-    ) {
+    telegramBotWithBehaviourAndLongPolling(token, scope = CoroutineScope(currentCoroutineContext() + SupervisorJob())) {
         onContentMessage(
             subcontextUpdatesFilter = MessageFilterByChat,
             initialFilter = { it !is BusinessContentMessage<*> || !it.sentByBusinessConnectionOwner }
@@ -38,15 +30,16 @@ suspend fun activateResenderBot(
                 executeUnsafe(
                     it.content.createResend(
                         chat.id,
-                        replyParameters = it.replyInfo?.messageMeta?.let { meta ->
-                            val quote = it.withContentOrNull<TextContent>()?.content?.quote
+                        messageThreadId = it.threadIdOrNull,
+                        replyParameters = it.replyInfo ?.messageMeta ?.let { meta ->
+                            val quote = it.withContentOrNull<TextContent>() ?.content ?.quote
                             ReplyParameters(
                                 meta,
-                                entities = quote?.textSources ?: emptyList(),
-                                quotePosition = quote?.position
+                                entities = quote ?.textSources ?: emptyList(),
+                                quotePosition = quote ?.position
                             )
                         },
-                        effectId = it.possiblyWithEffectMessageOrNull()?.effectId
+                        effectId = it.possiblyWithEffectMessageOrNull() ?.effectId
                     )
                 ) {
                     it.forEach(print)
@@ -56,7 +49,7 @@ suspend fun activateResenderBot(
             println("Answer info: $answer")
         }
 
-        allUpdatesFlow.subscribeLoggingDropExceptions(scope = this) {
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
             println(it)
         }
         print(bot.getMe())

ResenderBot/jvm_launcher/src/main/kotlin/ResenderBotJvm.kt

@@ -1,19 +1,4 @@
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.LogLevel
-import dev.inmo.kslog.common.defaultMessageFormatter
-import dev.inmo.kslog.common.setDefaultKSLog
-
 suspend fun main(args: Array<String>) {
-    val isDebug = args.getOrNull(1) == "debug"
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
-
     activateResenderBot(args.first()) {
         println(it)
     }

RightsChangerBot/build.gradle

@@ -18,5 +18,5 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
     implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-    implementation 'io.ktor:ktor-client-logging-jvm:3.2.3'
+    implementation 'io.ktor:ktor-client-logging-jvm:3.0.3'
 }

StarTransactionsBot/README.md

@@ -1,4 +1,4 @@
-# StarTransactionsBot
+# CustomBot
 
 This bot basically have no any useful behaviour, but you may customize it as a playground
 

StarTransactionsBot/src/main/kotlin/StarTransactionsBot.kt

@@ -15,7 +15,6 @@ import dev.inmo.tgbotapi.extensions.utils.extensions.sameChat
 import dev.inmo.tgbotapi.extensions.utils.types.buttons.*
 import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
 import dev.inmo.tgbotapi.requests.abstracts.asMultipartFile
-import dev.inmo.tgbotapi.types.ChatId
 import dev.inmo.tgbotapi.types.RawChatId
 import dev.inmo.tgbotapi.types.UserId
 import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
@@ -41,7 +40,7 @@ import kotlinx.coroutines.Dispatchers
  */
 suspend fun main(vararg args: String) {
     val botToken = args.first()
-    val adminUserId = args.getOrNull(1) ?.toLongOrNull() ?.let(::RawChatId) ?.let(::ChatId) ?: error("Pass user-admin for full access to the bot")
+    val adminUserId = args.getOrNull(1) ?.toLongOrNull() ?.let(::RawChatId) ?.let(::UserId) ?: error("Pass user-admin for full access to the bot")
 
     val isDebug = args.any { it == "debug" }
     val isTestServer = args.any { it == "testServer" }

StickerInfoBot/StickerInfoBotLib/src/commonMain/kotlin/StickerInfoBot.kt

@@ -1,5 +1,5 @@
 import dev.inmo.micro_utils.coroutines.defaultSafelyWithoutExceptionHandler
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.bot.ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.get.getCustomEmojiStickerOrNull
@@ -55,7 +55,7 @@ suspend fun activateStickerInfoBot(
             withTypingAction(it.chat) {
                 it.content.textSources.mapNotNull {
                     if (it is CustomEmojiTextSource) {
-                        getCustomEmojiStickerOrNull(it.customEmojiId)?.stickerSetName
+                        getCustomEmojiStickerOrNull(it.customEmojiId) ?.stickerSetName
                     } else {
                         null
                     }
@@ -76,7 +76,7 @@ suspend fun activateStickerInfoBot(
             )
         }
 
-        allUpdatesFlow.subscribeLoggingDropExceptions(scope = this) {
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
             println(it)
         }
     }.join()

SuggestedPosts/README.md

@@ -1,9 +0,0 @@
-# StickerSetHandler
-
-Send sticker to this bot to form your own stickers set. Send /delete to delete this sticker set
-
-## How to run
-
-```bash
-./gradlew run --args="TOKEN"
-```

SuggestedPosts/build.gradle

@@ -1,21 +0,0 @@
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-apply plugin: 'kotlin'
-apply plugin: 'application'
-
-mainClassName="SuggestedPostsBotKt"
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-}

SuggestedPosts/src/main/kotlin/SuggestedPostsBot.kt

@@ -1,140 +0,0 @@
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.LogLevel
-import dev.inmo.kslog.common.defaultMessageFormatter
-import dev.inmo.kslog.common.setDefaultKSLog
-import dev.inmo.micro_utils.coroutines.runCatchingLogging
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-import dev.inmo.tgbotapi.extensions.api.bot.getMe
-import dev.inmo.tgbotapi.extensions.api.bot.getMyStarBalance
-import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
-import dev.inmo.tgbotapi.extensions.api.send.reply
-import dev.inmo.tgbotapi.extensions.api.send.resend
-import dev.inmo.tgbotapi.extensions.api.send.send
-import dev.inmo.tgbotapi.extensions.api.suggested.approveSuggestedPost
-import dev.inmo.tgbotapi.extensions.api.suggested.declineSuggestedPost
-import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContextData
-import dev.inmo.tgbotapi.extensions.behaviour_builder.buildSubcontextInitialAction
-import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitSuggestedPostApproved
-import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitSuggestedPostDeclined
-import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChannelDirectMessagesConfigurationChanged
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSuggestedPostApprovalFailed
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSuggestedPostApproved
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSuggestedPostDeclined
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSuggestedPostPaid
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSuggestedPostRefunded
-import dev.inmo.tgbotapi.extensions.utils.channelDirectMessagesContentMessageOrNull
-import dev.inmo.tgbotapi.extensions.utils.previewChannelDirectMessagesChatOrNull
-import dev.inmo.tgbotapi.extensions.utils.suggestedChannelDirectMessagesContentMessageOrNull
-import dev.inmo.tgbotapi.types.message.SuggestedPostParameters
-import dev.inmo.tgbotapi.types.message.abstracts.ChannelPaidPost
-import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
-import dev.inmo.tgbotapi.types.update.abstracts.Update
-import dev.inmo.tgbotapi.utils.firstOf
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.filter
-import kotlinx.coroutines.flow.first
-
-/**
- * This place can be the playground for your code.
- */
-suspend fun main(vararg args: String) {
-    val botToken = args.first()
-
-    val isDebug = args.any { it == "debug" }
-    val isTestServer = args.any { it == "testServer" }
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
-
-    telegramBotWithBehaviourAndLongPolling(
-        botToken,
-        CoroutineScope(Dispatchers.Default),
-        testServer = isTestServer,
-    ) {
-        // start here!!
-        val me = getMe()
-        println(me)
-
-        onCommand("start") {
-            println(getChat(it.chat))
-        }
-
-        onContentMessage {
-            val message = it.channelDirectMessagesContentMessageOrNull() ?: return@onContentMessage
-            val chat = getChat(it.chat)
-            println(chat)
-
-            resend(
-                message.chat.id,
-                message.content,
-                suggestedPostParameters = SuggestedPostParameters()
-            )
-        }
-
-        onContentMessage(
-            subcontextUpdatesFilter = { _, _ -> true } // important to not miss updates in channel for waitSuggestedPost events
-        ) { message ->
-            val suggestedPost = message.suggestedChannelDirectMessagesContentMessageOrNull() ?: return@onContentMessage
-
-            firstOf(
-                {
-                    waitSuggestedPostApproved().filter {
-                        it.suggestedPostMessage ?.chat ?.id == message.chat.id
-                    }.first()
-                },
-                {
-                    waitSuggestedPostDeclined().filter {
-                        it.suggestedPostMessage ?.chat ?.id == message.chat.id
-                    }.first()
-                },
-                {
-                    for (i in 0 until 3) {
-                        delay(1000L)
-                        send(suggestedPost.chat, "${3 - i}")
-                    }
-                    declineSuggestedPost(suggestedPost)
-                },
-            )
-        }
-
-        onContentMessage(initialFilter = { it is ChannelPaidPost<*> }) {
-            println(it)
-        }
-
-        onSuggestedPostPaid {
-            println(it)
-            reply(it, "Paid")
-        }
-        onSuggestedPostApproved {
-            println(it)
-            reply(it, "Approved")
-        }
-        onSuggestedPostDeclined {
-            println(it)
-            reply(it, "Declined")
-        }
-        onSuggestedPostRefunded {
-            println(it)
-            reply(it, "Refunded")
-        }
-        onSuggestedPostApprovalFailed {
-            println(it)
-            reply(it, "Approval failed")
-        }
-
-        allUpdatesFlow.subscribeLoggingDropExceptions(this) {
-            println(it)
-        }
-    }.second.join()
-}

TagsBot/build.gradle

@@ -1,21 +0,0 @@
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-apply plugin: 'kotlin'
-apply plugin: 'application'
-
-mainClassName="TagsBotKt"
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-}

TagsBot/src/main/kotlin/TagsBot.kt

@@ -1,101 +0,0 @@
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.LogLevel
-import dev.inmo.kslog.common.defaultMessageFormatter
-import dev.inmo.kslog.common.setDefaultKSLog
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-import dev.inmo.tgbotapi.abstracts.FromUser
-import dev.inmo.tgbotapi.extensions.api.bot.getMe
-import dev.inmo.tgbotapi.extensions.api.business.getBusinessAccountGiftsFlow
-import dev.inmo.tgbotapi.extensions.api.chat.members.promoteChatAdministrator
-import dev.inmo.tgbotapi.extensions.api.chat.members.promoteChatMember
-import dev.inmo.tgbotapi.extensions.api.chat.members.setChatMemberTag
-import dev.inmo.tgbotapi.extensions.api.gifts.getChatGiftsFlow
-import dev.inmo.tgbotapi.extensions.api.gifts.getUserGiftsFlow
-import dev.inmo.tgbotapi.extensions.api.send.reply
-import dev.inmo.tgbotapi.extensions.api.send.withTypingAction
-import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onGiveawayCompleted
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onGiveawayContent
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onGiveawayCreated
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onGiveawayWinners
-import dev.inmo.tgbotapi.extensions.utils.extensions.raw.sender_chat
-import dev.inmo.tgbotapi.extensions.utils.extensions.raw.sender_tag
-import dev.inmo.tgbotapi.extensions.utils.fromUserOrNull
-import dev.inmo.tgbotapi.extensions.utils.groupContentMessageOrNull
-import dev.inmo.tgbotapi.extensions.utils.idChatIdentifierOrNull
-import dev.inmo.tgbotapi.extensions.utils.potentiallyFromUserGroupContentMessageOrNull
-import dev.inmo.tgbotapi.types.UserTag
-import dev.inmo.tgbotapi.types.chat.BusinessChat
-import dev.inmo.tgbotapi.types.chat.PrivateChat
-import dev.inmo.tgbotapi.types.chat.PublicChat
-import dev.inmo.tgbotapi.types.chat.UnknownChatType
-import dev.inmo.tgbotapi.types.gifts.OwnedGift
-import dev.inmo.tgbotapi.types.message.abstracts.OptionallyFromUserMessage
-import dev.inmo.tgbotapi.types.message.textsources.splitForText
-import dev.inmo.tgbotapi.utils.bold
-import dev.inmo.tgbotapi.utils.buildEntities
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-
-suspend fun main(vararg args: String) {
-    val botToken = args.first()
-
-    val isDebug = args.any { it == "debug" }
-    val isTestServer = args.any { it == "testServer" }
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
-
-    telegramBotWithBehaviourAndLongPolling(botToken, testServer = isTestServer) {
-        // start here!!
-        val me = getMe()
-        println(me)
-
-        onCommand("setChatMemberTag", requireOnlyCommandInMessage = false) {
-            val reply = it.replyTo ?.groupContentMessageOrNull() ?: return@onCommand
-            val title = it.content.text.removePrefix("/setChatMemberTag").removePrefix(" ")
-            setChatMemberTag(
-                chatId = reply.chat.id,
-                userId = reply.fromUserOrNull() ?.user ?.id ?: return@onCommand,
-                tag = UserTag(title)
-            )
-        }
-
-        onCommand("setCanManageTags", requireOnlyCommandInMessage = false) {
-            val reply = it.replyTo ?.groupContentMessageOrNull() ?: return@onCommand
-            val setOrUnset = it.content.text.removePrefix("/setCanManageTags").removePrefix(" ") == "true"
-            promoteChatAdministrator(
-                it.chat.id,
-                reply.fromUserOrNull() ?.user ?.id ?: return@onCommand,
-                canManageTags = setOrUnset
-            )
-        }
-
-        onCommand("removeChatMemberTag") {
-            val reply = it.replyTo ?.groupContentMessageOrNull() ?: return@onCommand
-            setChatMemberTag(
-                chatId = reply.chat.id,
-                userId = reply.fromUserOrNull() ?.user ?.id ?: return@onCommand,
-                tag = null
-            )
-        }
-
-        onContentMessage {
-            val groupContentMessage = it.potentiallyFromUserGroupContentMessageOrNull() ?: return@onContentMessage
-            reply(it, "Tag after casting: ${groupContentMessage.senderTag}")
-            reply(it, "Tag by getting via risk API: ${it.sender_tag}")
-        }
-
-        allUpdatesFlow.subscribeLoggingDropExceptions(this) {
-            println(it)
-        }
-    }.second.join()
-}

TopicsHandling/src/main/kotlin/TopicsHandling.kt

@@ -1,34 +1,15 @@
 import com.benasher44.uuid.uuid4
-import dev.inmo.kslog.common.w
-import dev.inmo.micro_utils.coroutines.runCatchingLogging
 import dev.inmo.micro_utils.coroutines.runCatchingSafely
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-import dev.inmo.tgbotapi.bot.TelegramBot
-import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
 import dev.inmo.tgbotapi.extensions.api.chat.forum.*
 import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onForumTopicClosed
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onForumTopicCreated
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onForumTopicEdited
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onForumTopicReopened
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onGeneralForumTopicHidden
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onGeneralForumTopicUnhidden
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onPrivateForumTopicCreated
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onPrivateForumTopicEdited
-import dev.inmo.tgbotapi.extensions.utils.forumChatOrNull
-import dev.inmo.tgbotapi.extensions.utils.forumContentMessageOrNull
-import dev.inmo.tgbotapi.extensions.utils.privateChatOrNull
-import dev.inmo.tgbotapi.extensions.utils.privateForumChatOrNull
 import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.flushAccumulatedUpdates
 import dev.inmo.tgbotapi.types.BotCommand
 import dev.inmo.tgbotapi.types.ForumTopic
-import dev.inmo.tgbotapi.types.chat.PrivateChat
 import dev.inmo.tgbotapi.types.commands.BotCommandScope
-import io.ktor.client.plugins.*
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
@@ -39,33 +20,13 @@ suspend fun main(vararg args: String) {
         CoroutineScope(Dispatchers.Default),
         defaultExceptionsHandler = {
             it.printStackTrace()
-        },
-        builder = {
-            client = client.config {
-                install(HttpTimeout) {
-                    requestTimeoutMillis = 30000
-                    socketTimeoutMillis = 30000
-                    connectTimeoutMillis = 30000
-                }
-            }
         }
     ) {
-        suspend fun TelegramBot.isPrivateForumsEnabled(): Boolean {
-            val me = getMe()
-            if (me.hasTopicsEnabled == false) {
-                Log.w("private forums are disabled. That means that they will not work in private chats")
-            }
-            return me.hasTopicsEnabled
-        }
-        println()
         flushAccumulatedUpdates()
-        allUpdatesFlow.subscribeLoggingDropExceptions(this) {
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
             println(it)
         }
         onCommand("start_test_topics") {
-            if (it.chat is PrivateChat && isPrivateForumsEnabled() == false) {
-                return@onCommand
-            }
             val forumTopic = createForumTopic(
                 it.chat,
                 "Test",
@@ -83,23 +44,21 @@ suspend fun main(vararg args: String) {
 
             reply(it, "Test topic has changed its name to Test 01")
 
-            if (it.chat.privateChatOrNull() == null) { // For private forums it is prohibited to close or reopen topics
-                delay(1000L)
-                closeForumTopic(
-                    it.chat.id,
-                    forumTopic.messageThreadId,
-                )
+            delay(1000L)
+            closeForumTopic(
+                it.chat.id,
+                forumTopic.messageThreadId,
+            )
 
-                reply(it, "Test topic has been closed")
+            reply(it, "Test topic has been closed")
 
-                delay(1000L)
-                reopenForumTopic(
-                    it.chat.id,
-                    forumTopic.messageThreadId,
-                )
+            delay(1000L)
+            reopenForumTopic(
+                it.chat.id,
+                forumTopic.messageThreadId,
+            )
 
-                reply(it, "Test topic has been reopened")
-            }
+            reply(it, "Test topic has been reopened")
 
             delay(1000L)
             deleteForumTopic(
@@ -109,111 +68,68 @@ suspend fun main(vararg args: String) {
 
             reply(it, "Test topic has been deleted")
 
-            if (it.chat.privateChatOrNull() == null) { // For private forums it is prohibited to close or reopen topics
-                delay(1000L)
-                hideGeneralForumTopic(
-                    it.chat.id,
-                )
+            delay(1000L)
+            hideGeneralForumTopic(
+                it.chat.id,
+            )
 
-                reply(it, "General topic has been hidden")
+            reply(it, "General topic has been hidden")
 
-                delay(1000L)
-                unhideGeneralForumTopic(
-                    it.chat.id
-                )
+            delay(1000L)
+            unhideGeneralForumTopic(
+                it.chat.id
+            )
 
-                reply(it, "General topic has been shown")
+            reply(it, "General topic has been shown")
 
-                delay(1000L)
-                runCatchingSafely(
-                    { _ ->
-                        reopenGeneralForumTopic(
-                            it.chat.id
-                        )
+            delay(1000L)
+            runCatchingSafely(
+                { _ ->
+                    reopenGeneralForumTopic(
+                        it.chat.id
+                    )
 
-                        closeGeneralForumTopic(
-                            it.chat.id
-                        )
-                    }
-                ) {
                     closeGeneralForumTopic(
                         it.chat.id
                     )
                 }
-
-                reply(it, "General topic has been closed")
-
-                delay(1000L)
-                reopenGeneralForumTopic(
+            ) {
+                closeGeneralForumTopic(
                     it.chat.id
                 )
-
-                reply(it, "General topic has been opened")
-
-                delay(1000L)
-                editGeneralForumTopic(
-                    it.chat.id,
-                    uuid4().toString().take(10)
-                )
-
-                reply(it, "General topic has been renamed")
-
-                delay(1000L)
-                editGeneralForumTopic(
-                    it.chat.id,
-                    "Main topic"
-                )
-
-                reply(it, "General topic has been renamed")
             }
 
+            reply(it, "General topic has been closed")
+
+            delay(1000L)
+            reopenGeneralForumTopic(
+                it.chat.id
+            )
+
+            reply(it, "General topic has been opened")
+
+            delay(1000L)
+            editGeneralForumTopic(
+                it.chat.id,
+                uuid4().toString().take(10)
+            )
+
+            reply(it, "General topic has been renamed")
+
+            delay(1000L)
+            editGeneralForumTopic(
+                it.chat.id,
+                "Main topic"
+            )
+
+            reply(it, "General topic has been renamed")
+
             delay(1000L)
         }
 
-        onCommand("delete_topic") {
-            val chat = it.chat.forumChatOrNull() ?: return@onCommand
-
-            deleteForumTopic(chat, chat.id.threadId ?: return@onCommand)
-        }
-
-        onCommand("unpin_all_forum_topic_messages") {
-            val chat = it.chat.forumChatOrNull() ?: return@onCommand
-
-            unpinAllForumTopicMessages(chat, chat.id.threadId ?: return@onCommand)
-        }
-
-        onForumTopicCreated {
-            reply(it, "Topic has been created")
-        }
-        onPrivateForumTopicCreated {
-            reply(it, "Private topic has been created")
-        }
-
-        onForumTopicEdited {
-            reply(it, "Topic has been edited")
-        }
-        onPrivateForumTopicEdited {
-            reply(it, "Private topic has been edited")
-        }
-
-        onForumTopicReopened {
-            reply(it, "Topic has been reopened")
-        }
-        onGeneralForumTopicHidden {
-            reply(it, "General topic has been hidden")
-        }
-        onGeneralForumTopicUnhidden {
-            reply(it, "General topic has been unhidden")
-        }
-
         setMyCommands(
             BotCommand("start_test_topics", "start test topics"),
-            BotCommand("delete_topic", "delete topic where message have been sent"),
-            BotCommand("unpin_all_forum_topic_messages", "delete topic where message have been sent"),
             scope = BotCommandScope.AllGroupChats
         )
-        allUpdatesFlow.subscribeLoggingDropExceptions(this) {
-            println(it)
-        }
     }.second.join()
 }

WebApp/build.gradle

@@ -35,7 +35,6 @@ kotlin {
                 implementation kotlin('stdlib')
                 implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:$serialization_version"
                 implementation "dev.inmo:tgbotapi.core:$telegram_bot_api_version"
-                implementation compose.runtime
             }
         }
 
@@ -43,6 +42,7 @@ kotlin {
             dependencies {
                 implementation "dev.inmo:tgbotapi.webapps:$telegram_bot_api_version"
                 implementation compose.web.core
+                implementation compose.runtime
             }
         }
 
@@ -51,7 +51,6 @@ kotlin {
                 implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
                 implementation "dev.inmo:micro_utils.ktor.server:$micro_utils_version"
                 implementation "io.ktor:ktor-server-cio:$ktor_version"
-                implementation compose.desktop.currentOs
             }
         }
     }

WebApp/src/jsMain/kotlin/main.kt

@@ -1,5 +1,5 @@
 import androidx.compose.runtime.*
-import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions
+import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
 import dev.inmo.tgbotapi.types.CustomEmojiId
 import dev.inmo.tgbotapi.types.userIdField
 import dev.inmo.tgbotapi.types.webAppQueryIdField
@@ -23,12 +23,10 @@ import kotlinx.dom.appendElement
 import kotlinx.dom.appendText
 import kotlinx.serialization.json.Json
 import org.jetbrains.compose.web.attributes.InputType
-import org.jetbrains.compose.web.attributes.placeholder
-import org.jetbrains.compose.web.css.Style
-import org.jetbrains.compose.web.css.StyleSheet
+import org.jetbrains.compose.web.css.DisplayStyle
 import org.jetbrains.compose.web.css.Color as ComposeColor
 import org.jetbrains.compose.web.css.backgroundColor
-import org.jetbrains.compose.web.css.color
+import org.jetbrains.compose.web.css.display
 import org.jetbrains.compose.web.dom.*
 import org.jetbrains.compose.web.dom.Text
 import org.jetbrains.compose.web.renderComposable
@@ -41,13 +39,6 @@ fun HTMLElement.log(text: String) {
     appendElement("p", {})
 }
 
-private object RootStyleSheet : StyleSheet() {
-    val rootClass by style {
-        color(ComposeColor("var(--tg-theme-text-color)"))
-        backgroundColor(ComposeColor("var(--tg-theme-bg-color)"))
-    }
-}
-
 @OptIn(ExperimentalUnsignedTypes::class)
 fun main() {
     console.log("Web app started")
@@ -55,14 +46,6 @@ fun main() {
     val baseUrl = window.location.origin.removeSuffix("/")
 
     renderComposable("root") {
-        Style(RootStyleSheet)
-        DisposableEffect(null) {
-            scopeElement.classList.add(RootStyleSheet.rootClass)
-
-            onDispose {
-                scopeElement.classList.remove(RootStyleSheet.rootClass)
-            }
-        }
         val scope = rememberCoroutineScope()
         val isSafeState = remember { mutableStateOf<Boolean?>(null) }
         val logsState = remember { mutableStateListOf<Any?>() }
@@ -104,7 +87,6 @@ fun main() {
         P()
         Text("Chat from WebAppInitData: ${webApp.initDataUnsafe.chat}")
 
-        H3 { Text("Emoji status management") }
         val emojiStatusAccessState = remember { mutableStateOf(false) }
         webApp.onEmojiStatusAccessRequested {
             emojiStatusAccessState.value = it.isAllowed
@@ -128,7 +110,7 @@ fun main() {
             userId ?.let { userId ->
                 Button({
                     onClick {
-                        scope.launchLoggingDropExceptions {
+                        scope.launchSafelyWithoutExceptions {
                             client.post("$baseUrl/setCustomEmoji") {
                                 parameter(userIdField, userId.long)
                                 setBody(
@@ -145,12 +127,10 @@ fun main() {
                 }
             }
         }
-        P()
 
-        H3 { Text("Call server method with webAppQueryIdField") }
         Button({
             onClick {
-                scope.launchLoggingDropExceptions {
+                scope.launchSafelyWithoutExceptions {
                     handleResult({ "Clicked" }) {
                         client.post("${window.location.origin.removeSuffix("/")}/inline") {
                             parameter(webAppQueryIdField, it)
@@ -164,40 +144,11 @@ fun main() {
             Text("Answer in chat button")
         }
 
-        H3 { Text("Hide keyboard") }
-        val hideCountdown = remember { mutableStateOf<Int?>(null) }
-        Button({
-            onClick {
-                hideCountdown.value = 5
-            }
-        }) {
-            if (hideCountdown.value == null) {
-                Text("Hide")
-            } else {
-                Text("Hide in ${hideCountdown.value} seconds")
-            }
-        }
-        LaunchedEffect(hideCountdown.value) {
-            val value = hideCountdown.value
-            when {
-                value == null -> return@LaunchedEffect
-                value > 0 -> {
-                    delay(1000)
-                    hideCountdown.value = hideCountdown.value ?.minus(1)
-                }
-                else -> {
-                    webApp.hideKeyboard()
-                    hideCountdown.value = null
-                }
-            }
-        }
-
         P()
-        H3 { Text("User info") }
         Text("Allow to write in private messages: ${webApp.initDataUnsafe.user ?.allowsWriteToPM ?: "User unavailable"}")
 
         P()
-        H3 { Text("Alerts") }
+        Text("Alerts:")
         Button({
             onClick {
                 webApp.showPopup(
@@ -235,22 +186,8 @@ fun main() {
         }) {
             Text("Alert")
         }
-        Button({
-            onClick {
-                webApp.showConfirm(
-                    "This is confirm message"
-                ) {
-                    logsState.add(
-                        "You have pressed \"${if (it) "Ok" else "Cancel"}\" in confirm"
-                    )
-                }
-            }
-        }) {
-            Text("Confirm")
-        }
 
         P()
-        H3 { Text("Write access callbacks") }
         Button({
             onClick {
                 webApp.requestWriteAccess()
@@ -269,7 +206,6 @@ fun main() {
         }
 
         P()
-        H3 { Text("Request contact") }
         Button({
             onClick {
                 webApp.requestContact()
@@ -284,9 +220,24 @@ fun main() {
         }) {
             Text("Request contact with callback")
         }
+        P()
+
+        Button({
+            onClick {
+                webApp.showConfirm(
+                    "This is confirm message"
+                ) {
+                    logsState.add(
+                        "You have pressed \"${if (it) "Ok" else "Cancel"}\" in confirm"
+                    )
+                }
+            }
+        }) {
+            Text("Confirm")
+        }
 
         P()
-        H3 { Text("Closing confirmation") }
+
         val isClosingConfirmationEnabledState = remember { mutableStateOf(webApp.isClosingConfirmationEnabled) }
         Button({
             onClick {
@@ -304,7 +255,7 @@ fun main() {
         }
 
         P()
-        H3 { Text("Colors") }
+
         val headerColor = remember { mutableStateOf<Color.Hex>(Color.Hex("#000000")) }
         fun updateHeaderColor() {
             val (r, g, b) = Random.nextUBytes(3)
@@ -329,6 +280,7 @@ fun main() {
         }
 
         P()
+
         val backgroundColor = remember { mutableStateOf<Color.Hex>(Color.Hex("#000000")) }
         fun updateBackgroundColor() {
             val (r, g, b) = Random.nextUBytes(3)
@@ -353,6 +305,7 @@ fun main() {
         }
 
         P()
+
         val bottomBarColor = remember { mutableStateOf<Color.Hex>(Color.Hex("#000000")) }
         fun updateBottomBarColor() {
             val (r, g, b) = Random.nextUBytes(3)
@@ -376,194 +329,8 @@ fun main() {
             }
         }
 
-        remember {
-            webApp.apply {
-
-                onThemeChanged {
-                    logsState.add("Theme changed: ${webApp.themeParams}")
-                }
-                onViewportChanged {
-                    logsState.add("Viewport changed: ${it}")
-                }
-                backButton.apply {
-                    onClick {
-                        logsState.add("Back button clicked")
-                        hapticFeedback.impactOccurred(
-                            HapticFeedbackStyle.Heavy
-                        )
-                    }
-                    show()
-                }
-                mainButton.apply {
-                    setText("Main button")
-                    setParams(
-                        BottomButtonParams(
-                            iconCustomEmojiId = CustomEmojiId("5370976574969486150") // 😏
-                        )
-                    )
-                    onClick {
-                        logsState.add("Main button clicked")
-                        hapticFeedback.notificationOccurred(
-                            HapticFeedbackType.Success
-                        )
-                    }
-                    show()
-                }
-                secondaryButton.apply {
-                    setText("Secondary button")
-                    setParams(
-                        BottomButtonParams(
-                            iconCustomEmojiId = CustomEmojiId("5370763368497944736") // 😒
-                        )
-                    )
-                    onClick {
-                        logsState.add("Secondary button clicked")
-                        hapticFeedback.notificationOccurred(
-                            HapticFeedbackType.Warning
-                        )
-                    }
-                    show()
-                }
-                onSettingsButtonClicked {
-                    logsState.add("Settings button clicked")
-                }
-                onWriteAccessRequested {
-                    logsState.add("Write access request result: $it")
-                }
-                onContactRequested {
-                    logsState.add("Contact request result: $it")
-                }
-            }
-        }
-
-        P()
-        let {
-            H3 { Text("Accelerometer") }
-            val enabledState = remember { mutableStateOf(webApp.accelerometer.isStarted) }
-            webApp.onAccelerometerStarted { enabledState.value = true }
-            webApp.onAccelerometerStopped { enabledState.value = false }
-            Button({
-                onClick {
-                    if (enabledState.value) {
-                        webApp.accelerometer.stop {  }
-                    } else {
-                        webApp.accelerometer.start(AccelerometerStartParams(200))
-                    }
-                }
-            }) {
-                Text("${if (enabledState.value) "Stop" else "Start"} accelerometer")
-            }
-            val xState = remember { mutableStateOf(webApp.accelerometer.x) }
-            val yState = remember { mutableStateOf(webApp.accelerometer.y) }
-            val zState = remember { mutableStateOf(webApp.accelerometer.z) }
-            fun updateValues() {
-                xState.value = webApp.accelerometer.x
-                yState.value = webApp.accelerometer.y
-                zState.value = webApp.accelerometer.z
-            }
-            remember {
-                updateValues()
-            }
-
-            webApp.onAccelerometerChanged {
-                updateValues()
-            }
-            if (enabledState.value) {
-                P()
-                Text("x: ${xState.value}")
-                P()
-                Text("y: ${yState.value}")
-                P()
-                Text("z: ${zState.value}")
-            }
-        }
         P()
 
-        let {
-            H3 { Text("Gyroscope") }
-            val enabledState = remember { mutableStateOf(webApp.gyroscope.isStarted) }
-            webApp.onGyroscopeStarted { enabledState.value = true }
-            webApp.onGyroscopeStopped { enabledState.value = false }
-            Button({
-                onClick {
-                    if (enabledState.value) {
-                        webApp.gyroscope.stop {  }
-                    } else {
-                        webApp.gyroscope.start(GyroscopeStartParams(200))
-                    }
-                }
-            }) {
-                Text("${if (enabledState.value) "Stop" else "Start"} gyroscope")
-            }
-            val xState = remember { mutableStateOf(webApp.gyroscope.x) }
-            val yState = remember { mutableStateOf(webApp.gyroscope.y) }
-            val zState = remember { mutableStateOf(webApp.gyroscope.z) }
-            fun updateValues() {
-                xState.value = webApp.gyroscope.x
-                yState.value = webApp.gyroscope.y
-                zState.value = webApp.gyroscope.z
-            }
-            remember {
-                updateValues()
-            }
-
-            webApp.onGyroscopeChanged {
-                updateValues()
-            }
-            if (enabledState.value) {
-                P()
-                Text("x: ${xState.value}")
-                P()
-                Text("y: ${yState.value}")
-                P()
-                Text("z: ${zState.value}")
-            }
-        }
-
-        P()
-        let {
-            H3 { Text("Device Orientation") }
-            val enabledState = remember { mutableStateOf(webApp.deviceOrientation.isStarted) }
-            webApp.onDeviceOrientationStarted { enabledState.value = true }
-            webApp.onDeviceOrientationStopped { enabledState.value = false }
-            Button({
-                onClick {
-                    if (enabledState.value) {
-                        webApp.deviceOrientation.stop {  }
-                    } else {
-                        webApp.deviceOrientation.start(DeviceOrientationStartParams(200))
-                    }
-                }
-            }) {
-                Text("${if (enabledState.value) "Stop" else "Start"} deviceOrientation")
-            }
-            val alphaState = remember { mutableStateOf(webApp.deviceOrientation.alpha) }
-            val betaState = remember { mutableStateOf(webApp.deviceOrientation.beta) }
-            val gammaState = remember { mutableStateOf(webApp.deviceOrientation.gamma) }
-            fun updateValues() {
-                alphaState.value = webApp.deviceOrientation.alpha
-                betaState.value = webApp.deviceOrientation.beta
-                gammaState.value = webApp.deviceOrientation.gamma
-            }
-            remember {
-                updateValues()
-            }
-
-            webApp.onDeviceOrientationChanged {
-                updateValues()
-            }
-            if (enabledState.value) {
-                P()
-                Text("alpha: ${alphaState.value}")
-                P()
-                Text("beta: ${betaState.value}")
-                P()
-                Text("gamma: ${gammaState.value}")
-            }
-        }
-
-        P()
-        H3 { Text("Cloud storage") }
         val storageTrigger = remember { mutableStateOf<List<Pair<CloudStorageKey, CloudStorageValue>>>(emptyList()) }
         fun updateCloudStorage() {
             webApp.cloudStorage.getAll {
@@ -616,126 +383,180 @@ fun main() {
             }
         }
 
-        P()
-        let { // DeviceStorage
-            H3 { Text("Device storage") }
-            val fieldKey = remember { mutableStateOf("") }
-            val fieldValue = remember { mutableStateOf("") }
-            val message = remember { mutableStateOf("") }
-            Div {
-                Text("Start type title of key. If value will be found in device storage, it will be shown in value input")
-            }
+        remember {
+            webApp.apply {
 
-            Input(InputType.Text) {
-                placeholder("Key")
-                value(fieldKey.value)
-                onInput {
-                    fieldKey.value = it.value
-                    webApp.deviceStorage.getItem(it.value) { e, v ->
-                        fieldValue.value = v ?: ""
-                        if (v == null) {
-                            message.value = "Value for key \"${it.value}\" has not been found"
-                        } else {
-                            message.value = "Value for key \"${it.value}\" has been found: \"$v\""
-                        }
-                    }
+                onThemeChanged {
+                    logsState.add("Theme changed: ${webApp.themeParams}")
                 }
-            }
-            Div {
-                Text("If you want to change value if typed key - just put it here")
-            }
-            Input(InputType.Text) {
-                placeholder("Value")
-                value(fieldValue.value)
-                onInput {
-                    fieldValue.value = it.value
-                    webApp.deviceStorage.setItem(fieldKey.value, it.value) { e, v ->
-                        if (v == true) {
-                            fieldValue.value = it.value
-                            message.value = "Value \"${it.value}\" has been saved"
-                        }
-                    }
+                onViewportChanged {
+                    logsState.add("Viewport changed: ${it}")
                 }
-            }
-
-            if (message.value.isNotEmpty()) {
-                Div { Text(message.value) }
-            }
-        }
-        P()
-
-        let { // DeviceStorage
-            H3 { Text("Secure storage") }
-            val fieldKey = remember { mutableStateOf("") }
-            val fieldValue = remember { mutableStateOf("") }
-            val message = remember { mutableStateOf("") }
-            val restorableState = remember { mutableStateOf(false) }
-            Div {
-                Text("Start type title of key. If value will be found in device storage, it will be shown in value input")
-            }
-
-            Input(InputType.Text) {
-                placeholder("Key")
-                value(fieldKey.value)
-                onInput {
-                    fieldKey.value = it.value
-                    webApp.secureStorage.getItem(it.value) { e, v, restorable ->
-                        fieldValue.value = v ?: ""
-                        restorableState.value = restorable == true
-                        if (v == null) {
-                            if (restorable == true) {
-                                message.value = "Value for key \"${it.value}\" has not been found, but can be restored"
-                            } else {
-                                message.value = "Value for key \"${it.value}\" has not been found. Error: $e"
-                            }
-                        } else {
-                            message.value = "Value for key \"${it.value}\" has been found: \"$v\""
-                        }
-                    }
-                }
-            }
-            if (restorableState.value) {
-                Button({
+                backButton.apply {
                     onClick {
-                        webApp.secureStorage.restoreItem(fieldKey.value) { e, v ->
-                            fieldValue.value = v ?: ""
-                            if (v == null) {
-                                message.value = "Value for key \"${fieldKey.value}\" has not been restored. Error: $e"
-                            } else {
-                                message.value = "Value for key \"${fieldKey.value}\" has been restored: \"$v\""
-                            }
-                        }
+                        logsState.add("Back button clicked")
+                        hapticFeedback.impactOccurred(
+                            HapticFeedbackStyle.Heavy
+                        )
                     }
-                }) {
-                    Text("Restore")
+                    show()
                 }
-            }
-            Div {
-                Text("If you want to change value if typed key - just put it here")
-            }
-            Input(InputType.Text) {
-                placeholder("Value")
-                value(fieldValue.value)
-                onInput {
-                    fieldValue.value = it.value
-                    webApp.secureStorage.setItem(fieldKey.value, it.value) { e, v ->
-                        if (v) {
-                            fieldValue.value = it.value
-                            message.value = "Value \"${it.value}\" has been saved"
-                        } else {
-                            message.value = "Value \"${it.value}\" has not been saved. Error: $e"
-                        }
+                mainButton.apply {
+                    setText("Main button")
+                    onClick {
+                        logsState.add("Main button clicked")
+                        hapticFeedback.notificationOccurred(
+                            HapticFeedbackType.Success
+                        )
                     }
+                    show()
+                }
+                secondaryButton.apply {
+                    setText("Secondary button")
+                    onClick {
+                        logsState.add("Secondary button clicked")
+                        hapticFeedback.notificationOccurred(
+                            HapticFeedbackType.Warning
+                        )
+                    }
+                    show()
+                }
+                onSettingsButtonClicked {
+                    logsState.add("Settings button clicked")
+                }
+                onWriteAccessRequested {
+                    logsState.add("Write access request result: $it")
+                }
+                onContactRequested {
+                    logsState.add("Contact request result: $it")
                 }
-            }
-
-            if (message.value.isNotEmpty()) {
-                Div { Text(message.value) }
             }
         }
         P()
 
-        H3 { Text("Events") }
+        let { // Accelerometer
+            val enabledState = remember { mutableStateOf(webApp.accelerometer.isStarted) }
+            webApp.onAccelerometerStarted { enabledState.value = true }
+            webApp.onAccelerometerStopped { enabledState.value = false }
+            Button({
+                onClick {
+                    if (enabledState.value) {
+                        webApp.accelerometer.stop {  }
+                    } else {
+                        webApp.accelerometer.start(AccelerometerStartParams(200))
+                    }
+                }
+            }) {
+                Text("${if (enabledState.value) "Stop" else "Start"} accelerometer")
+            }
+            val xState = remember { mutableStateOf(webApp.accelerometer.x) }
+            val yState = remember { mutableStateOf(webApp.accelerometer.y) }
+            val zState = remember { mutableStateOf(webApp.accelerometer.z) }
+            fun updateValues() {
+                xState.value = webApp.accelerometer.x
+                yState.value = webApp.accelerometer.y
+                zState.value = webApp.accelerometer.z
+            }
+            remember {
+                updateValues()
+            }
+
+            webApp.onAccelerometerChanged {
+                updateValues()
+            }
+            if (enabledState.value) {
+                P()
+                Text("x: ${xState.value}")
+                P()
+                Text("y: ${yState.value}")
+                P()
+                Text("z: ${zState.value}")
+            }
+        }
+        P()
+
+        let { // Gyroscope
+            val enabledState = remember { mutableStateOf(webApp.gyroscope.isStarted) }
+            webApp.onGyroscopeStarted { enabledState.value = true }
+            webApp.onGyroscopeStopped { enabledState.value = false }
+            Button({
+                onClick {
+                    if (enabledState.value) {
+                        webApp.gyroscope.stop {  }
+                    } else {
+                        webApp.gyroscope.start(GyroscopeStartParams(200))
+                    }
+                }
+            }) {
+                Text("${if (enabledState.value) "Stop" else "Start"} gyroscope")
+            }
+            val xState = remember { mutableStateOf(webApp.gyroscope.x) }
+            val yState = remember { mutableStateOf(webApp.gyroscope.y) }
+            val zState = remember { mutableStateOf(webApp.gyroscope.z) }
+            fun updateValues() {
+                xState.value = webApp.gyroscope.x
+                yState.value = webApp.gyroscope.y
+                zState.value = webApp.gyroscope.z
+            }
+            remember {
+                updateValues()
+            }
+
+            webApp.onGyroscopeChanged {
+                updateValues()
+            }
+            if (enabledState.value) {
+                P()
+                Text("x: ${xState.value}")
+                P()
+                Text("y: ${yState.value}")
+                P()
+                Text("z: ${zState.value}")
+            }
+        }
+        P()
+
+        let { // DeviceOrientation
+            val enabledState = remember { mutableStateOf(webApp.deviceOrientation.isStarted) }
+            webApp.onDeviceOrientationStarted { enabledState.value = true }
+            webApp.onDeviceOrientationStopped { enabledState.value = false }
+            Button({
+                onClick {
+                    if (enabledState.value) {
+                        webApp.deviceOrientation.stop {  }
+                    } else {
+                        webApp.deviceOrientation.start(DeviceOrientationStartParams(200))
+                    }
+                }
+            }) {
+                Text("${if (enabledState.value) "Stop" else "Start"} deviceOrientation")
+            }
+            val alphaState = remember { mutableStateOf(webApp.deviceOrientation.alpha) }
+            val betaState = remember { mutableStateOf(webApp.deviceOrientation.beta) }
+            val gammaState = remember { mutableStateOf(webApp.deviceOrientation.gamma) }
+            fun updateValues() {
+                alphaState.value = webApp.deviceOrientation.alpha
+                betaState.value = webApp.deviceOrientation.beta
+                gammaState.value = webApp.deviceOrientation.gamma
+            }
+            remember {
+                updateValues()
+            }
+
+            webApp.onDeviceOrientationChanged {
+                updateValues()
+            }
+            if (enabledState.value) {
+                P()
+                Text("alpha: ${alphaState.value}")
+                P()
+                Text("beta: ${betaState.value}")
+                P()
+                Text("gamma: ${gammaState.value}")
+            }
+        }
+        P()
+
         EventType.values().forEach { eventType ->
             when (eventType) {
                 EventType.AccelerometerChanged -> webApp.onAccelerometerChanged { /*logsState.add("AccelerometerChanged") /* see accelerometer block */ */ }

WebApp/src/jvmMain/kotlin/WebAppServer.kt

@@ -1,5 +1,4 @@
 import dev.inmo.kslog.common.*
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.micro_utils.ktor.server.createKtorServer
 import dev.inmo.tgbotapi.extensions.api.answers.answerInlineQuery
@@ -196,7 +195,7 @@ suspend fun main(vararg args: String) {
             BotCommand("reply_markup", "Use to get reply markup keyboard with web app trigger"),
             BotCommand("inline", "Use to get inline keyboard with web app trigger"),
         )
-        allUpdatesFlow.subscribeLoggingDropExceptions(this) {
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
             println(it)
         }
         println(getMe())

build.gradle

@@ -14,8 +14,8 @@ allprojects {
         nativePartTemplate = "${rootProject.projectDir.absolutePath}/native_template.gradle"
     }
     repositories {
+        mavenLocal()
         mavenCentral()
-        google()
         if (project.hasProperty("GITHUB_USER") && project.hasProperty("GITHUB_TOKEN")) {
             maven {
                 url "https://maven.pkg.github.com/InsanusMokrassar/TelegramBotAPI"
@@ -26,8 +26,7 @@ allprojects {
             }
         }
 
-        maven { url "https://proxy.nexus.inmo.dev/repository/maven-releases/" }
-        mavenLocal()
+        maven { url "https://nexus.inmo.dev/repository/maven-releases/" }
     }
 }
 

gradle.properties

@@ -5,9 +5,9 @@ org.gradle.jvmargs=-Xmx3148m
 kotlin.daemon.jvmargs=-Xmx3g -Xms500m
 
 
-kotlin_version=2.2.21
-telegram_bot_api_version=31.2.0
-micro_utils_version=0.26.9
-serialization_version=1.10.0
-ktor_version=3.3.2
-compose_version=1.8.2
+kotlin_version=2.1.20
+telegram_bot_api_version=24.0.2
+micro_utils_version=0.25.3
+serialization_version=1.8.0
+ktor_version=3.1.1
+compose_version=1.7.3

gradle/wrapper/gradle-wrapper.properties

@@ -2,4 +2,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.12.1-bin.zip

settings.gradle

@@ -6,7 +6,7 @@ include ":HelloBot"
 
 include ":PollsBot"
 
-include ":MyBot"
+include ":GetMeBot"
 
 include ":DeepLinksBot"
 
@@ -59,13 +59,3 @@ include ":CustomBot"
 include ":MemberUpdatedWatcherBot"
 
 include ":WebHooks"
-
-include ":SuggestedPosts"
-
-include ":ChecklistsBot"
-
-include ":DraftsBot"
-
-include ":GiftsBot"
-
-include ":TagsBot"