Update dependency dev.inmo:micro_utils.ktor.server to v0.26.2

Update ktor monorepo to v3.2.3

BusinessConnectionsBot/src/main/kotlin/BusinessConnectionsBot.kt

@@ -2,24 +2,69 @@ 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.accessibleMessageOrNull
+import dev.inmo.tgbotapi.extensions.utils.commonMessageOrNull
+import dev.inmo.tgbotapi.extensions.utils.extendedPrivateChatOrThrow
 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()
@@ -34,21 +79,25 @@ 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")
         }
@@ -71,7 +120,20 @@ 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(sent, "User have sent this message to you in the ${businessContentMessage.businessConnectionId.string} related chat")
+                    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}")
+                            }
+                        }
+                    )
                 }
             }
         }
@@ -98,5 +160,328 @@ 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()
 }

CustomBot/src/main/kotlin/CustomBot.kt

@@ -4,10 +4,27 @@ 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.send.reply
+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.onCommand
+import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
+import dev.inmo.tgbotapi.types.update.abstracts.Update
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 
+private var BehaviourContextData.update: Update?
+    get() = get("update") as? Update
+    set(value) = set("update", value)
+
+private var BehaviourContextData.commonMessage: CommonMessage<*>?
+    get() = get("commonMessage") as? CommonMessage<*>
+    set(value) = set("commonMessage", value)
+
 /**
  * This place can be the playground for your code.
  */
@@ -38,12 +55,44 @@ suspend fun main(vararg args: String) {
                     }
                 }
             }
+        },
+        subcontextInitialAction = buildSubcontextInitialAction {
+            add {
+                data.update = it
+            }
         }
     ) {
         // start here!!
         val me = getMe()
         println(me)
 
+        onCommand("start") {
+            println(data.update)
+            println(data.commonMessage)
+            println(getChat(it.chat))
+        }
+
+        onCommand(
+            "additional_command",
+            additionalSubcontextInitialAction = { update, commonMessage ->
+                data.commonMessage = commonMessage
+            }
+        ) {
+            println(data.update)
+            println(data.commonMessage)
+        }
+
+        onCommand("getMyStarBalance") {
+            reply(
+                to = it,
+                text = getMyStarBalance().toString()
+            )
+        }
+
+        onChannelDirectMessagesConfigurationChanged {
+            println(it.chatEvent)
+        }
+
         allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
             println(it)
         }

InlineQueriesBot/build.gradle

@@ -12,14 +12,16 @@ plugins {
     id "org.jetbrains.kotlin.multiplatform"
 }
 
-apply plugin: 'application'
-
-mainClassName="InlineQueriesBotKt"
-
 apply from: "$nativePartTemplate"
 
 kotlin {
-    jvm()
+    jvm {
+        binaries {
+            executable {
+                mainClass.set("InlineQueriesBotKt")
+            }
+        }
+    }
 
     sourceSets {
         commonMain {
@@ -27,12 +29,9 @@ kotlin {
                 implementation kotlin('stdlib')
 
                 api "dev.inmo:tgbotapi:$telegram_bot_api_version"
+                api "io.ktor:ktor-client-logging:$ktor_version"
             }
         }
     }
 }
 
-dependencies {
-    implementation 'io.ktor:ktor-client-logging-jvm:2.3.12'
-}
-

InlineQueriesBot/src/commonMain/kotlin/Bot.kt

@@ -1,4 +1,4 @@
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
 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.subscribeSafelyWithoutExceptions(this) {
+        allUpdatesFlow.subscribeLoggingDropExceptions(scope = this) {
             println(it)
         }
 

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

@@ -1,4 +1,4 @@
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
 import dev.inmo.tgbotapi.bot.ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.answers.answer
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
@@ -45,6 +45,9 @@ fun InlineKeyboardBuilder.includePageButtons(page: Int, count: Int) {
             }
         }
     }
+    row {
+        copyTextButton("Command copy button", "/inline $page $count")
+    }
 
     row {
         if (page - 1 > 2) {
@@ -84,11 +87,13 @@ suspend fun activateKeyboardsBot(
 
     bot.buildBehaviourWithLongPolling(CoroutineScope(currentCoroutineContext() + SupervisorJob())) {
         onCommandWithArgs("inline") { message, args ->
-            val numberOfPages = args.firstOrNull() ?.toIntOrNull() ?: 10
+            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
             reply(
                 message,
                 replyMarkup = inlineKeyboard {
-                    includePageButtons(1, numberOfPages)
+                    includePageButtons(page, numberOfPages)
                 }
             ) {
                 regular("Your inline keyboard with $numberOfPages pages")
@@ -133,7 +138,8 @@ 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,
@@ -165,7 +171,7 @@ suspend fun activateKeyboardsBot(
 
         setMyCommands(BotCommand("inline", "Creates message with pagination inline keyboard"))
 
-        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
+        allUpdatesFlow.subscribeLoggingDropExceptions(scope = this) {
             println(it)
         }
     }.join()

KeyboardsBot/jvm_launcher/src/main/kotlin/KeyboardsBotJvm.kt

@@ -1,7 +1,21 @@
+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 kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 
 suspend fun main(args: Array<String>) {
+    val isDebug = args.any { it == "debug" }
+
+    if (isDebug) {
+        setDefaultKSLog(
+            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
+                println(defaultMessageFormatter(level, tag, message, throwable))
+            }
+        )
+    }
+
     withContext(Dispatchers.IO) { // IO for inheriting of it in side of activateKeyboardsBot
         activateKeyboardsBot(args.first()) {
             println(it)

RandomFileSenderBot/build.gradle

@@ -12,12 +12,14 @@ plugins {
     id "org.jetbrains.kotlin.multiplatform"
 }
 
-apply plugin: 'application'
-
-mainClassName="RandomFileSenderBotKt"
-
 kotlin {
-    jvm()
+    jvm {
+        binaries {
+            executable {
+                mainClass.set("RandomFileSenderBotKt")
+            }
+        }
+    }
 
     sourceSets {
         commonMain {

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

@@ -1,4 +1,7 @@
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+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.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.send.withTypingAction
 import dev.inmo.tgbotapi.extensions.behaviour_builder.filters.MessageFilterByChat
@@ -10,7 +13,9 @@ 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
@@ -19,7 +24,10 @@ 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 }
@@ -31,15 +39,15 @@ suspend fun activateResenderBot(
                     it.content.createResend(
                         chat.id,
                         messageThreadId = it.threadIdOrNull,
-                        replyParameters = it.replyInfo ?.messageMeta ?.let { meta ->
+                        replyParameters = it.replyInfo?.messageMeta?.let { meta ->
-                            val quote = it.withContentOrNull<TextContent>() ?.content ?.quote
+                            val quote = it.withContentOrNull<TextContent>()?.content?.quote
                             ReplyParameters(
                                 meta,
-                                entities = quote ?.textSources ?: emptyList(),
+                                entities = quote?.textSources ?: emptyList(),
-                                quotePosition = quote ?.position
+                                quotePosition = quote?.position
                             )
                         },
-                        effectId = it.possiblyWithEffectMessageOrNull() ?.effectId
+                        effectId = it.possiblyWithEffectMessageOrNull()?.effectId
                     )
                 ) {
                     it.forEach(print)
@@ -49,7 +57,7 @@ suspend fun activateResenderBot(
             println("Answer info: $answer")
         }
 
-        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
+        allUpdatesFlow.subscribeLoggingDropExceptions(scope = this) {
             println(it)
         }
         print(bot.getMe())

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:2.3.12'
+    implementation 'io.ktor:ktor-client-logging-jvm:3.2.3'
 }

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

@@ -1,5 +1,5 @@
 import dev.inmo.micro_utils.coroutines.defaultSafelyWithoutExceptionHandler
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
 import dev.inmo.tgbotapi.bot.ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.get.getCustomEmojiStickerOrNull
@@ -12,7 +12,7 @@ import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSticke
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onText
 import dev.inmo.tgbotapi.types.StickerType
 import dev.inmo.tgbotapi.types.message.textsources.CustomEmojiTextSource
-import dev.inmo.tgbotapi.types.message.textsources.regular
+import dev.inmo.tgbotapi.types.message.textsources.regularTextSource
 import dev.inmo.tgbotapi.types.message.textsources.separateForText
 import dev.inmo.tgbotapi.types.stickers.StickerSet
 import dev.inmo.tgbotapi.utils.bold
@@ -55,14 +55,14 @@ suspend fun activateStickerInfoBot(
             withTypingAction(it.chat) {
                 it.content.textSources.mapNotNull {
                     if (it is CustomEmojiTextSource) {
-                        getCustomEmojiStickerOrNull(it.customEmojiId) ?.stickerSetName
+                        getCustomEmojiStickerOrNull(it.customEmojiId)?.stickerSetName
                     } else {
                         null
                     }
                 }.distinct().map {
                     getStickerSet(it)
                 }.distinct().flatMap {
-                    it.buildInfo() + regular("\n")
+                    it.buildInfo() + regularTextSource("\n")
                 }.separateForText().map { entities ->
                     reply(it, entities)
                 }
@@ -76,7 +76,7 @@ suspend fun activateStickerInfoBot(
             )
         }
 
-        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
+        allUpdatesFlow.subscribeLoggingDropExceptions(scope = this) {
             println(it)
         }
     }.join()

UserChatShared/src/main/kotlin/UserChatShared.kt

@@ -15,8 +15,8 @@ import dev.inmo.tgbotapi.extensions.utils.types.buttons.*
 import dev.inmo.tgbotapi.types.BotCommand
 import dev.inmo.tgbotapi.types.chat.PrivateChat
 import dev.inmo.tgbotapi.types.keyboardButtonRequestUserLimit
-import dev.inmo.tgbotapi.types.message.textsources.mention
 import dev.inmo.tgbotapi.types.request.RequestId
+import dev.inmo.tgbotapi.utils.mention
 import dev.inmo.tgbotapi.utils.row
 
 suspend fun main(args: Array<String>) {
@@ -287,7 +287,7 @@ suspend fun main(args: Array<String>) {
                     it,
                 ) {
                     +"You have shared "
-                    +mention(
+                    mention(
                         when (it.chatEvent.requestId) {
                             requestIdUserOrBot -> "user or bot"
                             requestIdUserNonPremium -> "non premium user"

WebApp/build.gradle

@@ -11,12 +11,19 @@ buildscript {
 plugins {
     id "org.jetbrains.kotlin.multiplatform"
     id "org.jetbrains.kotlin.plugin.serialization"
+
+    id "org.jetbrains.kotlin.plugin.compose" version "$kotlin_version"
+    id "org.jetbrains.compose" version "$compose_version"
 }
 
-apply plugin: 'application'
-
 kotlin {
-    jvm()
+    jvm {
+        binaries {
+            executable {
+                mainClass.set("WebAppServerKt")
+            }
+        }
+    }
     js(IR) {
         browser()
         binaries.executable()
@@ -27,12 +34,15 @@ kotlin {
             dependencies {
                 implementation kotlin('stdlib')
                 implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:$serialization_version"
+                implementation "dev.inmo:tgbotapi.core:$telegram_bot_api_version"
+                implementation compose.runtime
             }
         }
 
         jsMain {
             dependencies {
                 implementation "dev.inmo:tgbotapi.webapps:$telegram_bot_api_version"
+                implementation compose.web.core
             }
         }
 
@@ -41,15 +51,12 @@ 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
             }
         }
     }
 }
 
-application {
-    mainClassName = "WebAppServerKt"
-}
-
 tasks.getByName("compileKotlinJvm")
         .dependsOn(jsBrowserDistribution)
 tasks.getByName("compileKotlinJvm").configure {

WebApp/src/commonMain/kotlin/CustomEmojiIdToSet.kt

@@ -0,0 +1,3 @@
+import dev.inmo.tgbotapi.types.CustomEmojiId
+
+val CustomEmojiIdToSet = CustomEmojiId("5424939566278649034")

WebApp/src/jsMain/kotlin/main.kt

@@ -1,22 +1,36 @@
-import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
+import androidx.compose.runtime.*
+import dev.inmo.micro_utils.coroutines.launchLoggingDropExceptions
+import dev.inmo.tgbotapi.types.userIdField
 import dev.inmo.tgbotapi.types.webAppQueryIdField
 import dev.inmo.tgbotapi.webapps.*
+import dev.inmo.tgbotapi.webapps.accelerometer.AccelerometerStartParams
 import dev.inmo.tgbotapi.webapps.cloud.*
+import dev.inmo.tgbotapi.webapps.events.*
+import dev.inmo.tgbotapi.webapps.gyroscope.GyroscopeStartParams
 import dev.inmo.tgbotapi.webapps.haptic.HapticFeedbackStyle
 import dev.inmo.tgbotapi.webapps.haptic.HapticFeedbackType
+import dev.inmo.tgbotapi.webapps.orientation.DeviceOrientationStartParams
 import dev.inmo.tgbotapi.webapps.popup.*
 import io.ktor.client.HttpClient
 import io.ktor.client.request.*
 import io.ktor.client.statement.bodyAsText
 import io.ktor.http.*
 import io.ktor.http.content.TextContent
-import kotlinx.browser.document
 import kotlinx.browser.window
 import kotlinx.coroutines.*
 import kotlinx.dom.appendElement
 import kotlinx.dom.appendText
-import kotlinx.dom.clear
 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.Color as ComposeColor
+import org.jetbrains.compose.web.css.backgroundColor
+import org.jetbrains.compose.web.css.color
+import org.jetbrains.compose.web.dom.*
+import org.jetbrains.compose.web.dom.Text
+import org.jetbrains.compose.web.renderComposable
 import org.w3c.dom.*
 import kotlin.random.Random
 import kotlin.random.nextUBytes
@@ -26,17 +40,36 @@ 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")
     val client = HttpClient()
     val baseUrl = window.location.origin.removeSuffix("/")
 
-    window.onload = {
+    renderComposable("root") {
-        val scope = CoroutineScope(Dispatchers.Default)
+        Style(RootStyleSheet)
-        runCatching {
+        DisposableEffect(null) {
+            scopeElement.classList.add(RootStyleSheet.rootClass)
 
-            scope.launchSafelyWithoutExceptions {
+            onDispose {
+                scopeElement.classList.remove(RootStyleSheet.rootClass)
+            }
+        }
+        val scope = rememberCoroutineScope()
+        val isSafeState = remember { mutableStateOf<Boolean?>(null) }
+        val logsState = remember { mutableStateListOf<Any?>() }
+
+//        Text(window.location.href)
+//        P()
+
+        LaunchedEffect(baseUrl) {
             val response = client.post("$baseUrl/check") {
                 setBody(
                     Json.encodeToString(
@@ -47,42 +80,125 @@ fun main() {
             }
             val dataIsSafe = response.bodyAsText().toBoolean()
 
-                document.body ?.log(
             if (dataIsSafe) {
-                        "Data is safe"
+                isSafeState.value = true
+                logsState.add("Data is safe")
             } else {
-                        "Data is unsafe"
+                isSafeState.value = false
+                logsState.add("Data is unsafe")
             }
-                )
 
-                document.body ?.log(
+            logsState.add(
                 webApp.initDataUnsafe.chat.toString()
             )
         }
 
-            document.body ?.appendElement("button") {
+        Text(
-                addEventListener("click", {
+            when (isSafeState.value) {
-                    scope.launchSafelyWithoutExceptions {
+                null -> "Checking safe state..."
+                true -> "Data is safe"
+                false -> "Data is unsafe"
+            }
+        )
+        P()
+        Text("Chat from WebAppInitData: ${webApp.initDataUnsafe.chat}")
+
+        H3 { Text("Emoji status management") }
+        val emojiStatusAccessState = remember { mutableStateOf(false) }
+        webApp.onEmojiStatusAccessRequested {
+            emojiStatusAccessState.value = it.isAllowed
+        }
+        Button({
+            onClick {
+                webApp.requestEmojiStatusAccess()
+            }
+        }) {
+            Text("Request custom emoji status access")
+        }
+        if (emojiStatusAccessState.value) {
+            Button({
+                onClick {
+                    webApp.setEmojiStatus(CustomEmojiIdToSet/* android custom emoji id */)
+                }
+            }) {
+                Text("Set custom emoji status")
+            }
+            val userId = webApp.initDataUnsafe.user ?.id
+            userId ?.let { userId ->
+                Button({
+                    onClick {
+                        scope.launchLoggingDropExceptions {
+                            client.post("$baseUrl/setCustomEmoji") {
+                                parameter(userIdField, userId.long)
+                                setBody(
+                                    Json.encodeToString(
+                                        WebAppDataWrapper.serializer(),
+                                        WebAppDataWrapper(webApp.initData, webApp.initDataUnsafe.hash)
+                                    )
+                                )
+                            }
+                        }
+                    }
+                }) {
+                    Text("Set custom emoji status via bot")
+                }
+            }
+        }
+        P()
+
+        H3 { Text("Call server method with webAppQueryIdField") }
+        Button({
+            onClick {
+                scope.launchLoggingDropExceptions {
                     handleResult({ "Clicked" }) {
                         client.post("${window.location.origin.removeSuffix("/")}/inline") {
                             parameter(webAppQueryIdField, it)
                             setBody(TextContent("Clicked", ContentType.Text.Plain))
-                                document.body ?.log(url.build().toString())
+                            logsState.add(url.build().toString())
                         }.coroutineContext.job.join()
                     }
                 }
-                })
+            }
-                appendText("Answer in chat button")
+        }) {
-            } ?: window.alert("Unable to load body")
+            Text("Answer in chat button")
+        }
 
-            document.body ?.appendElement("p", {})
+        H3 { Text("Hide keyboard") }
-            document.body ?.appendText("Allow to write in private messages: ${webApp.initDataUnsafe.user ?.allowsWriteToPM ?: "User unavailable"}")
+        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
+                }
+            }
+        }
 
-            document.body ?.appendElement("p", {})
+        P()
-            document.body ?.appendText("Alerts:")
+        H3 { Text("User info") }
+        Text("Allow to write in private messages: ${webApp.initDataUnsafe.user ?.allowsWriteToPM ?: "User unavailable"}")
 
-            document.body ?.appendElement("button") {
+        P()
-                addEventListener("click", {
+        H3 { Text("Alerts") }
+        Button({
+            onClick {
                 webApp.showPopup(
                     PopupParams(
                         "It is sample title of default button",
@@ -92,7 +208,7 @@ fun main() {
                         DestructivePopupButton("destructive", "Destructive button")
                     )
                 ) {
-                        document.body ?.log(
+                    logsState.add(
                         when (it) {
                             "default" -> "You have clicked default button in popup"
                             "ok" -> "You have clicked ok button in popup"
@@ -101,208 +217,176 @@ fun main() {
                         }
                     )
                 }
-                })
+            }
-                appendText("Popup")
+        }) {
-            } ?: window.alert("Unable to load body")
+            Text("Popup")
-
+        }
-            document.body ?.appendElement("button") {
+        Button({
-                addEventListener("click", {
+            onClick {
                 webApp.showAlert(
                     "This is alert message"
                 ) {
-                        document.body ?.log(
+                    logsState.add(
                         "You have closed alert"
                     )
                 }
-                })
+            }
-                appendText("Alert")
+        }) {
-            } ?: window.alert("Unable to load body")
+            Text("Alert")
-
+        }
-            document.body ?.appendElement("p", {})
+        Button({
-
+            onClick {
-            document.body ?.appendElement("button") {
-                addEventListener("click", { webApp.requestWriteAccess() })
-                appendText("Request write access without callback")
-            } ?: window.alert("Unable to load body")
-
-            document.body ?.appendElement("button") {
-                addEventListener("click", { webApp.requestWriteAccess { document.body ?.log("Write access request result: $it") } })
-                appendText("Request write access with callback")
-            } ?: window.alert("Unable to load body")
-
-            document.body ?.appendElement("p", {})
-
-            document.body ?.appendElement("button") {
-                addEventListener("click", { webApp.requestContact() })
-                appendText("Request contact without callback")
-            } ?: window.alert("Unable to load body")
-
-            document.body ?.appendElement("button") {
-                addEventListener("click", { webApp.requestContact { document.body ?.log("Contact request result: $it") } })
-                appendText("Request contact with callback")
-            } ?: window.alert("Unable to load body")
-
-            document.body ?.appendElement("p", {})
-
-            document.body ?.appendElement("button") {
-                addEventListener("click", {
                 webApp.showConfirm(
                     "This is confirm message"
                 ) {
-                        document.body ?.log(
+                    logsState.add(
                         "You have pressed \"${if (it) "Ok" else "Cancel"}\" in confirm"
                     )
                 }
-                })
+            }
-                appendText("Confirm")
+        }) {
-            } ?: window.alert("Unable to load body")
+            Text("Confirm")
+        }
 
-            document.body ?.appendElement("p", {})
+        P()
+        H3 { Text("Write access callbacks") }
+        Button({
+            onClick {
+                webApp.requestWriteAccess()
+            }
+        }) {
+            Text("Request write access without callback")
+        }
+        Button({
+            onClick {
+                webApp.requestWriteAccess {
+                    logsState.add("Write access request result: $it")
+                }
+            }
+        }) {
+            Text("Request write access with callback")
+        }
 
-            document.body ?.appendElement("button") {
+        P()
-                fun updateText() {
+        H3 { Text("Request contact") }
-                    textContent = if (webApp.isClosingConfirmationEnabled) {
+        Button({
+            onClick {
+                webApp.requestContact()
+            }
+        }) {
+            Text("Request contact without callback")
+        }
+        Button({
+            onClick {
+                webApp.requestContact { logsState.add("Contact request result: $it") }
+            }
+        }) {
+            Text("Request contact with callback")
+        }
+
+        P()
+        H3 { Text("Closing confirmation") }
+        val isClosingConfirmationEnabledState = remember { mutableStateOf(webApp.isClosingConfirmationEnabled) }
+        Button({
+            onClick {
+                webApp.toggleClosingConfirmation()
+                isClosingConfirmationEnabledState.value = webApp.isClosingConfirmationEnabled
+            }
+        }) {
+            Text(
+                if (isClosingConfirmationEnabledState.value) {
                     "Disable closing confirmation"
                 } else {
                     "Enable closing confirmation"
                 }
+            )
         }
-                addEventListener("click", {
-                    webApp.toggleClosingConfirmation()
-                    updateText()
-                })
-                updateText()
-            } ?: window.alert("Unable to load body")
 
-            document.body ?.appendElement("p", {})
+        P()
-
+        H3 { Text("Colors") }
-            document.body ?.appendElement("button") {
+        val headerColor = remember { mutableStateOf<Color.Hex>(Color.Hex("#000000")) }
         fun updateHeaderColor() {
             val (r, g, b) = Random.nextUBytes(3)
-                    val hex = Color.Hex(r, g, b)
+            headerColor.value = Color.Hex(r, g, b)
-                    webApp.setHeaderColor(hex)
+            webApp.setHeaderColor(headerColor.value)
-                    (this as? HTMLButtonElement) ?.style ?.backgroundColor = hex.value
-                    textContent = "Header color: ${webApp.headerColor ?.uppercase()} (click to change)"
         }
-                addEventListener("click", {
+        DisposableEffect(0) {
             updateHeaderColor()
-                })
+            onDispose {  }
+        }
+        Button({
+            style {
+                backgroundColor(ComposeColor(headerColor.value.value))
+            }
+            onClick {
                 updateHeaderColor()
-            } ?: window.alert("Unable to load body")
+            }
+        }) {
+            key(headerColor.value) {
+                Text("Header color: ${webApp.headerColor ?.uppercase()} (click to change)")
+            }
+        }
 
-            document.body ?.appendElement("p", {})
+        P()
-
+        val backgroundColor = remember { mutableStateOf<Color.Hex>(Color.Hex("#000000")) }
-            document.body ?.appendElement("button") {
         fun updateBackgroundColor() {
             val (r, g, b) = Random.nextUBytes(3)
-                    val hex = Color.Hex(r, g, b)
+            backgroundColor.value = Color.Hex(r, g, b)
-                    webApp.setBackgroundColor(hex)
+            webApp.setBackgroundColor(backgroundColor.value)
-                    (this as? HTMLButtonElement) ?.style ?.backgroundColor = hex.value
-                    textContent = "Background color: ${webApp.backgroundColor ?.uppercase()} (click to change)"
         }
-                addEventListener("click", {
+        DisposableEffect(0) {
             updateBackgroundColor()
-                })
+            onDispose {  }
+        }
+        Button({
+            style {
+                backgroundColor(ComposeColor(backgroundColor.value.value))
+            }
+            onClick {
                 updateBackgroundColor()
-            } ?: window.alert("Unable to load body")
+            }
+        }) {
+            key(backgroundColor.value) {
+                Text("Background color: ${webApp.backgroundColor ?.uppercase()} (click to change)")
+            }
+        }
 
-            document.body ?.appendElement("p", {})
+        P()
-
+        val bottomBarColor = remember { mutableStateOf<Color.Hex>(Color.Hex("#000000")) }
-            document.body ?.appendElement("button") {
         fun updateBottomBarColor() {
             val (r, g, b) = Random.nextUBytes(3)
-                    val hex = Color.Hex(r, g, b)
+            bottomBarColor.value = Color.Hex(r, g, b)
-                    webApp.setBottomBarColor(hex)
+            webApp.setBottomBarColor(bottomBarColor.value)
-                    (this as? HTMLButtonElement) ?.style ?.backgroundColor = hex.value
-                    textContent = "Bottom bar color: ${webApp.bottomBarColor ?.uppercase()} (click to change)"
         }
-                addEventListener("click", {
+        DisposableEffect(0) {
             updateBottomBarColor()
-                })
+            onDispose {  }
+        }
+        Button({
+            style {
+                backgroundColor(ComposeColor(bottomBarColor.value.value))
+            }
+            onClick {
                 updateBottomBarColor()
-            } ?: window.alert("Unable to load body")
-
-            document.body ?.appendElement("p", {})
-
-            fun Element.updateCloudStorageContent() {
-                clear()
-                webApp.cloudStorage.getAll {
-                    it.onSuccess {
-                        document.body ?.log(it.toString())
-                        appendElement("label") { textContent = "Cloud storage" }
-
-                        appendElement("p", {})
-
-                        it.forEach { (k, v) ->
-                            appendElement("div") {
-                                val kInput = appendElement("input", {}) as HTMLInputElement
-                                val vInput = appendElement("input", {}) as HTMLInputElement
-
-                                kInput.value = k.key
-                                vInput.value = v.value
-
-                                appendElement("button") {
-                                    addEventListener("click", {
-                                        if (k.key == kInput.value) {
-                                            webApp.cloudStorage.set(k.key, vInput.value) {
-                                                document.body ?.log(it.toString())
-                                                this@updateCloudStorageContent.updateCloudStorageContent()
             }
-                                        } else {
+        }) {
-                                            webApp.cloudStorage.remove(k.key) {
+            key(bottomBarColor.value) {
-                                                it.onSuccess {
+                Text("Bottom bar color: ${webApp.bottomBarColor ?.uppercase()} (click to change)")
-                                                    webApp.cloudStorage.set(kInput.value, vInput.value) {
-                                                        document.body ?.log(it.toString())
-                                                        this@updateCloudStorageContent.updateCloudStorageContent()
-                                                    }
-                                                }
-                                            }
-                                        }
-                                    })
-                                    this.textContent = "Save"
             }
         }
 
-                            appendElement("p", {})
+        remember {
-                        }
-                        appendElement("label") { textContent = "Cloud storage: add new" }
-
-                        appendElement("p", {})
-
-                        appendElement("div") {
-                            val kInput = appendElement("input", {}) as HTMLInputElement
-
-                            appendElement("button") {
-                                textContent = "Add key"
-                                addEventListener("click", {
-                                    webApp.cloudStorage.set(kInput.value, kInput.value) {
-                                        document.body ?.log(it.toString())
-                                        this@updateCloudStorageContent.updateCloudStorageContent()
-                                    }
-                                })
-                            }
-                        }
-
-                        appendElement("p", {})
-                    }.onFailure {
-                        document.body ?.log(it.stackTraceToString())
-                    }
-                }
-            }
-            val cloudStorageContentDiv = document.body ?.appendElement("div") {} as HTMLDivElement
-
-            document.body ?.appendElement("p", {})
-
             webApp.apply {
+
                 onThemeChanged {
-                    document.body ?.log("Theme changed: ${webApp.themeParams}")
+                    logsState.add("Theme changed: ${webApp.themeParams}")
                 }
                 onViewportChanged {
-                    document.body ?.log("Viewport changed: ${it.isStateStable}")
+                    logsState.add("Viewport changed: ${it}")
                 }
                 backButton.apply {
                     onClick {
-                        document.body ?.log("Back button clicked")
+                        logsState.add("Back button clicked")
                         hapticFeedback.impactOccurred(
                             HapticFeedbackStyle.Heavy
                         )
@@ -312,7 +396,7 @@ fun main() {
                 mainButton.apply {
                     setText("Main button")
                     onClick {
-                        document.body ?.log("Main button clicked")
+                        logsState.add("Main button clicked")
                         hapticFeedback.notificationOccurred(
                             HapticFeedbackType.Success
                         )
@@ -322,7 +406,7 @@ fun main() {
                 secondaryButton.apply {
                     setText("Secondary button")
                     onClick {
-                        document.body ?.log("Secondary button clicked")
+                        logsState.add("Secondary button clicked")
                         hapticFeedback.notificationOccurred(
                             HapticFeedbackType.Warning
                         )
@@ -330,22 +414,407 @@ fun main() {
                     show()
                 }
                 onSettingsButtonClicked {
-                    document.body ?.log("Settings button clicked")
+                    logsState.add("Settings button clicked")
                 }
                 onWriteAccessRequested {
-                    document.body ?.log("Write access request result: $it")
+                    logsState.add("Write access request result: $it")
                 }
                 onContactRequested {
-                    document.body ?.log("Contact request result: $it")
+                    logsState.add("Contact request result: $it")
                 }
             }
-            webApp.ready()
+        }
-            document.body ?.appendElement("input", {
+
-                (this as HTMLInputElement).value = window.location.href
+        P()
-            })
+        let {
-            cloudStorageContentDiv.updateCloudStorageContent()
+            H3 { Text("Accelerometer") }
-        }.onFailure {
+            val enabledState = remember { mutableStateOf(webApp.accelerometer.isStarted) }
-            window.alert(it.stackTraceToString())
+            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 {
+                it.onSuccess {
+                    storageTrigger.value = it.toList().sortedBy { it.first.key }
+                }
+            }
+        }
+        key(storageTrigger.value) {
+            storageTrigger.value.forEach { (key, value) ->
+                val keyState = remember { mutableStateOf(key.key) }
+                val valueState = remember { mutableStateOf(value.value) }
+                Input(InputType.Text) {
+                    value(key.key)
+                    onInput { keyState.value = it.value }
+                }
+                Input(InputType.Text) {
+                    value(value.value)
+                    onInput { valueState.value = it.value }
+                }
+                Button({
+                    onClick {
+                        if (key.key != keyState.value) {
+                            webApp.cloudStorage.remove(key)
+                        }
+                        webApp.cloudStorage.set(keyState.value, valueState.value)
+                        updateCloudStorage()
+                    }
+                }) {
+                    Text("Save")
+                }
+            }
+            let { // new element adding
+                val keyState = remember { mutableStateOf("") }
+                val valueState = remember { mutableStateOf("") }
+                Input(InputType.Text) {
+                    onInput { keyState.value = it.value }
+                }
+                Input(InputType.Text) {
+                    onInput { valueState.value = it.value }
+                }
+                Button({
+                    onClick {
+                        webApp.cloudStorage.set(keyState.value, valueState.value)
+                        updateCloudStorage()
+                    }
+                }) {
+                    Text("Save")
+                }
+            }
+        }
+
+        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")
+            }
+
+            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\""
+                        }
+                    }
+                }
+            }
+            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"
+                        }
+                    }
+                }
+            }
+
+            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({
+                    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\""
+                            }
+                        }
+                    }
+                }) {
+                    Text("Restore")
+                }
+            }
+            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"
+                        }
+                    }
+                }
+            }
+
+            if (message.value.isNotEmpty()) {
+                Div { Text(message.value) }
+            }
+        }
+        P()
+
+        H3 { Text("Events") }
+        EventType.values().forEach { eventType ->
+            when (eventType) {
+                EventType.AccelerometerChanged -> webApp.onAccelerometerChanged { /*logsState.add("AccelerometerChanged") /* see accelerometer block */ */ }
+                EventType.AccelerometerFailed -> webApp.onAccelerometerFailed {
+                    logsState.add(it.error)
+                }
+                EventType.AccelerometerStarted -> webApp.onAccelerometerStarted { logsState.add("AccelerometerStarted") }
+                EventType.AccelerometerStopped -> webApp.onAccelerometerStopped { logsState.add("AccelerometerStopped") }
+                EventType.Activated -> webApp.onActivated { logsState.add("Activated") }
+                EventType.BackButtonClicked -> webApp.onBackButtonClicked { logsState.add("BackButtonClicked") }
+                EventType.BiometricAuthRequested -> webApp.onBiometricAuthRequested {
+                    logsState.add(it.isAuthenticated)
+                }
+                EventType.BiometricManagerUpdated -> webApp.onBiometricManagerUpdated { logsState.add("BiometricManagerUpdated") }
+                EventType.BiometricTokenUpdated -> webApp.onBiometricTokenUpdated {
+                    logsState.add(it.isUpdated)
+                }
+                EventType.ClipboardTextReceived -> webApp.onClipboardTextReceived {
+                    logsState.add(it.data)
+                }
+                EventType.ContactRequested -> webApp.onContactRequested {
+                    logsState.add(it.status)
+                }
+                EventType.ContentSafeAreaChanged -> webApp.onContentSafeAreaChanged { logsState.add("ContentSafeAreaChanged") }
+                EventType.Deactivated -> webApp.onDeactivated { logsState.add("Deactivated") }
+                EventType.DeviceOrientationChanged -> webApp.onDeviceOrientationChanged { /*logsState.add("DeviceOrientationChanged")*//* see accelerometer block */ }
+                EventType.DeviceOrientationFailed -> webApp.onDeviceOrientationFailed {
+                    logsState.add(it.error)
+                }
+                EventType.DeviceOrientationStarted -> webApp.onDeviceOrientationStarted { logsState.add("DeviceOrientationStarted") }
+                EventType.DeviceOrientationStopped -> webApp.onDeviceOrientationStopped { logsState.add("DeviceOrientationStopped") }
+                EventType.EmojiStatusAccessRequested -> webApp.onEmojiStatusAccessRequested {
+                    logsState.add(it.status)
+                }
+                EventType.EmojiStatusFailed -> webApp.onEmojiStatusFailed {
+                    logsState.add(it.error)
+                }
+                EventType.EmojiStatusSet -> webApp.onEmojiStatusSet { logsState.add("EmojiStatusSet") }
+                EventType.FileDownloadRequested -> webApp.onFileDownloadRequested {
+                    logsState.add(it.status)
+                }
+                EventType.FullscreenChanged -> webApp.onFullscreenChanged { logsState.add("FullscreenChanged") }
+                EventType.FullscreenFailed -> webApp.onFullscreenFailed {
+                    logsState.add(it.error)
+                }
+                EventType.GyroscopeChanged -> webApp.onGyroscopeChanged { /*logsState.add("GyroscopeChanged")*//* see gyroscope block */ }
+                EventType.GyroscopeFailed -> webApp.onGyroscopeFailed {
+                    logsState.add(it.error)
+                }
+                EventType.GyroscopeStarted -> webApp.onGyroscopeStarted { logsState.add("GyroscopeStarted")/* see accelerometer block */ }
+                EventType.GyroscopeStopped -> webApp.onGyroscopeStopped { logsState.add("GyroscopeStopped") }
+                EventType.HomeScreenAdded -> webApp.onHomeScreenAdded { logsState.add("HomeScreenAdded") }
+                EventType.HomeScreenChecked -> webApp.onHomeScreenChecked {
+                    logsState.add(it.status)
+                }
+                EventType.InvoiceClosed -> webApp.onInvoiceClosed { url, status ->
+                    logsState.add(url)
+                    logsState.add(status)
+                }
+                EventType.LocationManagerUpdated -> webApp.onLocationManagerUpdated { logsState.add("LocationManagerUpdated") }
+                EventType.LocationRequested -> webApp.onLocationRequested {
+                    logsState.add(it.locationData)
+                }
+                EventType.MainButtonClicked -> webApp.onMainButtonClicked { logsState.add("MainButtonClicked") }
+                EventType.PopupClosed -> webApp.onPopupClosed {
+                    logsState.add(it.buttonId)
+                }
+                EventType.QrTextReceived -> webApp.onQrTextReceived {
+                    logsState.add(it.data)
+                }
+                EventType.SafeAreaChanged -> webApp.onSafeAreaChanged { logsState.add("SafeAreaChanged") }
+                EventType.ScanQrPopupClosed -> webApp.onScanQrPopupClosed { logsState.add("ScanQrPopupClosed") }
+                EventType.SecondaryButtonClicked -> webApp.onSecondaryButtonClicked { logsState.add("SecondaryButtonClicked") }
+                EventType.SettingsButtonClicked -> webApp.onSettingsButtonClicked { logsState.add("SettingsButtonClicked") }
+                EventType.ShareMessageFailed -> webApp.onShareMessageFailed {
+                    logsState.add(it.error)
+                }
+                EventType.ShareMessageSent -> webApp.onShareMessageSent { logsState.add("ShareMessageSent") }
+                EventType.ThemeChanged -> webApp.onThemeChanged { logsState.add("ThemeChanged") }
+                EventType.ViewportChanged -> webApp.onViewportChanged {
+                    logsState.add(it)
+                }
+                EventType.WriteAccessRequested -> webApp.onWriteAccessRequested {
+                    logsState.add(it.status)
+                }
+            }
+        }
+
+        logsState.forEach {
+            P { Text(it.toString()) }
         }
     }
 }

WebApp/src/jsMain/resources/index.html

@@ -10,6 +10,7 @@
         <title>Web App Example</title>
     </head>
     <body>
+        <div id="root"></div>
         <script type="application/javascript" src="https://telegram.org/js/telegram-web-app.js"></script>
         <script type="application/javascript" src="WebApp.js"></script>
     </body>

WebApp/src/jvmMain/kotlin/WebAppServer.kt

@@ -1,4 +1,5 @@
 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
@@ -6,6 +7,7 @@ import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
 import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.api.send.send
+import dev.inmo.tgbotapi.extensions.api.set.setUserEmojiStatus
 import dev.inmo.tgbotapi.extensions.api.telegramBot
 import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onBaseInlineQuery
@@ -16,12 +18,9 @@ import dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard
 import dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard
 import dev.inmo.tgbotapi.extensions.utils.types.buttons.webAppButton
 import dev.inmo.tgbotapi.requests.answers.InlineQueryResultsButton
-import dev.inmo.tgbotapi.types.BotCommand
+import dev.inmo.tgbotapi.types.*
 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.LinkPreviewOptions
-import dev.inmo.tgbotapi.types.webAppQueryIdField
 import dev.inmo.tgbotapi.types.webapps.WebAppInfo
 import dev.inmo.tgbotapi.utils.*
 import io.ktor.http.*
@@ -30,7 +29,6 @@ import io.ktor.server.http.content.*
 import io.ktor.server.request.*
 import io.ktor.server.response.*
 import io.ktor.server.routing.*
-import kotlinx.coroutines.Dispatchers
 import kotlinx.serialization.json.Json
 import java.io.File
 
@@ -63,10 +61,7 @@ suspend fun main(vararg args: String) {
     val bot = telegramBot(telegramBotAPIUrlsKeeper)
     createKtorServer(
         "0.0.0.0",
-        args.getOrNull(2) ?.toIntOrNull() ?: 8080,
+        args.getOrNull(2) ?.toIntOrNull() ?: 8080
-        additionalEngineEnvironmentConfigurator = {
-            parentCoroutineContext += Dispatchers.IO
-        }
     ) {
         routing {
             val baseJsFolder = File("WebApp/build/dist/js/")
@@ -108,6 +103,26 @@ suspend fun main(vararg args: String) {
 
                 call.respond(HttpStatusCode.OK, isSafe.toString())
             }
+            post("setCustomEmoji") {
+                val requestBody = call.receiveText()
+                val webAppCheckData = Json.decodeFromString(WebAppDataWrapper.serializer(), requestBody)
+
+                val isSafe = telegramBotAPIUrlsKeeper.checkWebAppData(webAppCheckData.data, webAppCheckData.hash)
+                val rawUserId = call.parameters[userIdField] ?.toLongOrNull() ?.let(::RawChatId) ?: error("$userIdField should be presented as long value")
+
+                val set = if (isSafe) {
+                    runCatching {
+                        bot.setUserEmojiStatus(
+                            UserId(rawUserId),
+                            CustomEmojiIdToSet
+                        )
+                    }.getOrElse { false }
+                } else {
+                    false
+                }
+
+                call.respond(HttpStatusCode.OK, set.toString())
+            }
         }
     }.start(false)
 
@@ -181,7 +196,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.subscribeSafelyWithoutExceptions(this) {
+        allUpdatesFlow.subscribeLoggingDropExceptions(this) {
             println(it)
         }
         println(getMe())

WebHooks/README.md

@@ -0,0 +1,28 @@
+# WebHooks
+
+Launches webhook-based simple bot. Use `/start` with bot to get simple info about webhooks
+
+## Launch
+
+```bash
+../gradlew run --args="BOT_TOKEN https://sample.com it/is/subpath 8080 debug"
+```
+
+Required arguments:
+
+1. Token
+2. Arguments starting with `https://`
+
+Optional arguments:
+
+* Any argument == `debug` to enable debug mode
+* Any argument **not** starting with `https://` and **not** equal to `debug` as **subpath** (will be used as
+subroute to place listening of webhooks)
+* Any argument as number of port
+
+Sample: `TOKEN https://sample.com it/is/subpath 8080` will result to:
+
+* `TOKEN` used as token
+* Bot will set up its webhook info as `https://sample.com/it/is/subpath`
+* Bot will set up to listen webhooks on route `it/is/subpath`
+* Bot will start to listen any incoming request on port `8080` and url `0.0.0.0`

WebHooks/build.gradle

@@ -0,0 +1,23 @@
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: 'kotlin'
+apply plugin: 'application'
+
+mainClassName="WebHooksKt"
+
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+    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"
+}

WebHooks/src/main/kotlin/WebHooks.kt

@@ -0,0 +1,87 @@
+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.ktor.server.createKtorServer
+import dev.inmo.tgbotapi.bot.ktor.telegramBot
+import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
+import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.extensions.api.webhook.setWebhookInfo
+import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviour
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
+import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.includeWebhookHandlingInRoute
+import dev.inmo.tgbotapi.types.BotCommand
+import dev.inmo.tgbotapi.types.chat.PrivateChat
+import dev.inmo.tgbotapi.utils.buildEntities
+import io.ktor.server.routing.*
+
+/**
+ * Launches webhook-based simple bot. Required arguments:
+ *
+ * 1. Token
+ * *. Arguments starting with `https://`
+ *
+ * Optional arguments:
+ *
+ * *. Any argument == `debug` to enable debug mode
+ * *. Any argument **not** starting with `https://` and **not** equal to `debug` as **subpath** (will be used as
+ * subroute to place listening of webhooks)
+ * *. Any argument as number of port
+ *
+ * Sample: `TOKEN https://sample.com it/is/subpath 8080` will result to:
+ *
+ * * `TOKEN` used as token
+ * * Bot will set up its webhook info as `https://sample.com/it/is/subpath`
+ * * Bot will set up to listen webhooks on route `it/is/subpath`
+ * * Bot will start to listen any incoming request on port `8080` and url `0.0.0.0`
+ */
+suspend fun main(args: Array<String>) {
+    val botToken = args.first()
+    val address = args.first { it.startsWith("https://") }
+    val subpath = args.drop(1).firstOrNull { it != address && it != "debug" }
+    val port = args.firstNotNullOfOrNull { it.toIntOrNull() } ?: 8080
+    val isDebug = args.any { it == "debug" }
+
+    if (isDebug) {
+        setDefaultKSLog(
+            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
+                println(defaultMessageFormatter(level, tag, message, throwable))
+            }
+        )
+    }
+
+    val bot = telegramBot(botToken)
+
+    val behaviourContext = bot.buildBehaviour (defaultExceptionsHandler = { it.printStackTrace() }) {
+        onCommand("start", initialFilter = { it.chat is PrivateChat }) {
+            reply(
+                it,
+                buildEntities {
+                    +"Url: $address" + "\n"
+                    +"Listening server: 0.0.0.0" + "\n"
+                    +"Listening port: $port"
+                }
+            )
+        }
+
+        setMyCommands(BotCommand("start", "Get webhook info"))
+    }
+
+    val webhookInfoSubpath = subpath ?.let { "/" + it.removePrefix("/") } ?: "" // drop leading `/` to add it in the beginning for correct construction of subpath
+    bot.setWebhookInfo(address + webhookInfoSubpath)
+
+    createKtorServer(
+        "0.0.0.0",
+        port,
+    ) {
+        routing {
+            if (subpath == null) {
+                includeWebhookHandlingInRoute(behaviourContext, block = behaviourContext.asUpdateReceiver)
+            } else {
+                route(subpath) {
+                    includeWebhookHandlingInRoute(behaviourContext, block = behaviourContext.asUpdateReceiver)
+                }
+            }
+        }
+    }.start(true)
+}

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,6 +26,12 @@ allprojects {
             }
         }
 
-        maven { url "https://nexus.inmo.dev/repository/maven-releases/" }
+        maven { url "https://proxy.nexus.inmo.dev/repository/maven-releases/" }
+        mavenLocal()
     }
 }
+
+// Fix of https://youtrack.jetbrains.com/issue/KTOR-7912/Module-not-found-errors-when-executing-browserProductionWebpack-task-since-3.0.2
+rootProject.plugins.withType(org.jetbrains.kotlin.gradle.targets.js.yarn.YarnPlugin.class) {
+    rootProject.kotlinYarn.resolution("ws", "8.18.0")
+}

gradle.properties

@@ -5,8 +5,9 @@ org.gradle.jvmargs=-Xmx3148m
 kotlin.daemon.jvmargs=-Xmx3g -Xms500m
 
 
-kotlin_version=2.0.21
+kotlin_version=2.2.0
-telegram_bot_api_version=18.2.2
+telegram_bot_api_version=27.1.2
-micro_utils_version=0.22.7
+micro_utils_version=0.26.2
-serialization_version=1.7.3
+serialization_version=1.9.0
-ktor_version=2.3.12
+ktor_version=3.2.3
+compose_version=1.8.2

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.9-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip

settings.gradle

@@ -57,3 +57,5 @@ include ":GiveawaysBot"
 include ":CustomBot"
 
 include ":MemberUpdatedWatcherBot"
+
+include ":WebHooks"