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

.github/workflows/build.yml

@@ -10,11 +10,10 @@ jobs:
       - uses: actions/checkout@v2
       - name: Install dependencies
         run: |
-          sudo apt update
           sudo apt install -y libcurl4-openssl-dev
       - name: Set up JDK 17
         uses: actions/setup-java@v1
         with:
           java-version: 17
       - name: Build with Gradle
-        run: ./gradlew build --no-daemon
+        run: ./gradlew build

.gitignore

@@ -1,5 +1,4 @@
 .idea
-.kotlin
 out/*
 *.iml
 target

.template/bot/.env

@@ -1,2 +0,0 @@
-title=$prompt
-subtitle=Subtitle of {{$title}}

.template/bot/{{$title}}/README.md

@@ -1,9 +0,0 @@
-# {{$title}}
-
-
-
-## Launch
-
-```bash
-../gradlew run --args="BOT_TOKEN"
-```

.template/bot/{{$title}}/build.gradle

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

.template/bot/{{$title}}/src/main/kotlin/{{$title}}.kt

@@ -1,34 +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.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-
-/**
- * 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" }
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
-
-    telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO)) {
-        // start here!!
-        val me = getMe()
-        println(me)
-
-        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) { println(it) }
-    }.second.join()
-}

.template/module_generator.main.kts

@@ -1,208 +0,0 @@
-#!/usr/bin/env kotlin
-/**
- * Generates files and folders as they have been put in the folder. Envs uses common syntax, but
- * values may contains {{${'$'}sampleVariable}} parts, where {{${'$'}sampleVariable}} will be replaced with variable value.
- * Example:
- *
- * .env:
- * sampleVariable=${'$'}prompt # require request from command line
- *         sampleVariable2=just some value
- * sampleVariable3=${'$'}{sampleVariable}.${'$'}{sampleVariable2}
- *
- * Result variables:
- * sampleVariable=your input in console # lets imagine you typed it
- * sampleVariable2=just some value
- * sampleVariable3=your input in console.just some value
- *
- * To use these variables in template, you will need to write {{${'$'}sampleVariable}}.
- * You may use it in text of files as well as in files/folders names.
- *
- * Usage: kotlin generator.kts [args] folders...
- * Args:
- * -e, --env: Path to file with args for generation; Use "${'$'}prompt" as values to read variable value from console
- * -o, --outputFolder: Folder where templates should be used. Folder of calling by default
- *         folders: Folders-templates
- */
-import java.io.File
-
-val console = System.console()
-
-fun String.replaceWithVariables(envs: Map<String, String>): String {
-    var currentString = this
-    var changed = false
-
-    do {
-        changed = false
-        envs.forEach { (k, v) ->
-            val previousString = currentString
-            currentString = currentString.replace("{{$${k}}}", v)
-            changed = changed || currentString != previousString
-        }
-    } while (changed)
-
-    return currentString
-}
-
-fun requestVariable(variableName: String, defaultValue: String?): String {
-    console.printf("Enter value for variable $variableName${defaultValue ?.let { " [$it]" } ?: ""}: ")
-    return console.readLine().ifEmpty { defaultValue } ?: ""
-}
-
-fun readEnvs(content: String, presets: Map<String, String>): Map<String, String> {
-    val initialEnvs = mutableMapOf<String, String>()
-    content.split("\n").forEach {
-        val withoutComment = it.replace(Regex("\\#.*"), "")
-
-        runCatching {
-            val (key, value) = withoutComment.split("=")
-            val existsValue = presets[key]
-            if (value == "\$prompt") {
-                initialEnvs[key] = requestVariable(key, existsValue)
-            } else {
-                initialEnvs[key] = requestVariable(key, value.replaceWithVariables(initialEnvs))
-            }
-        }
-    }
-    var i = 0
-    val readEnvs = initialEnvs.toMutableMap()
-    while (i < readEnvs.size) {
-        val key = readEnvs.keys.elementAt(i)
-        val currentValue = readEnvs.getValue(key)
-        val withReplaced = currentValue.replaceWithVariables(readEnvs)
-        var changed = false
-        if (withReplaced != currentValue) {
-            i = 0
-            readEnvs[key] = withReplaced
-        } else {
-            i++
-        }
-    }
-    return presets + readEnvs
-}
-
-var envFile: File? = null
-var outputFolder: File = File("./") // current folder by default
-val templatesFolders = mutableListOf<File>()
-var extensions: List<String>? = null
-
-fun readParameters() {
-    var i = 0
-    while (i < args.size) {
-        val arg = args[i]
-        when (arg) {
-            "--env",
-            "-e" -> {
-                i++
-                envFile = File(args[i])
-            }
-            "--extensions",
-            "-ex" -> {
-                i++
-                extensions = args[i].split(",")
-            }
-            "--outputFolder",
-            "-o" -> {
-                i++
-                outputFolder = File(args[i])
-            }
-            "--help",
-            "-h" -> {
-                println("""
-                    Generates files and folders as the have been put in the folder. Envs uses common syntax, but
-                    values may contains {{${'$'}sampleVariable}} parts, where {{${'$'}sampleVariable}} will be replaced with variable value.
-                    Example:
-                    
-                    .env:
-                    sampleVariable=${'$'}prompt # require request from command line
-                    sampleVariable2=just some value
-                    sampleVariable3=${'$'}{sampleVariable}.${'$'}{sampleVariable2}
-                    
-                    Result variables:
-                    sampleVariable=your input in console # lets imagine you typed it
-                    sampleVariable2=just some value
-                    sampleVariable3=your input in console.just some value
-                    
-                    To use these variables in template, you will need to write {{${'$'}sampleVariable}}.
-                    You may use it in text of files as well as in files/folders names.
-                    
-                    Usage: kotlin generator.kts [args] folders...
-                    Args:
-                        -e, --env: Path to file with args for generation; Use "${'$'}prompt" as values to read variable value from console
-                        -o, --outputFolder: Folder where templates should be used. Folder of calling by default
-                        folders: Folders-templates
-                """.trimIndent())
-                Runtime.getRuntime().exit(0)
-            }
-            else -> {
-                val potentialFile = File(arg)
-                println("Potential file/folder as template: ${potentialFile.absolutePath}")
-                runCatching {
-                    if (potentialFile.exists()) {
-                        println("Adding file/folder as template: ${potentialFile.absolutePath}")
-                        templatesFolders.add(potentialFile)
-                    }
-                }.onFailure { e ->
-                    println("Unable to use folder $arg as template folder")
-                    e.printStackTrace()
-                }
-            }
-        }
-        i++
-    }
-}
-
-readParameters()
-
-val envs: MutableMap<String, String> = envFile ?.let { readEnvs(it.readText(), emptyMap()) } ?.toMutableMap() ?: mutableMapOf()
-
-println(
-    """
-    Result environments:
-        ${envs.toList().joinToString("\n        ") { (k, v) -> "$k=$v" }}
-    Result extensions:
-        ${extensions ?.joinToString()}
-    Input folders:
-        ${templatesFolders.joinToString("\n        ") { it.absolutePath }}
-    Output folder:
-        ${outputFolder.absolutePath}
-    """.trimIndent()
-)
-
-fun File.handleTemplate(targetFolder: File, envs: Map<String, String>) {
-    println("Handling $absolutePath")
-    val localEnvs = File(absolutePath, ".env").takeIf { it.exists() } ?.let {
-        println("Reading .env in ${absolutePath}")
-        readEnvs(it.readText(), envs)
-    } ?: envs
-    println(
-        """
-    Local environments:
-        ${localEnvs.toList().joinToString("\n        ") { (k, v) -> "$k=$v" }}
-    """.trimIndent()
-    )
-    val newName = name.replaceWithVariables(localEnvs)
-    println("New name $newName")
-    when {
-        !exists() -> return
-        isFile -> {
-            val content = useLines {
-                it.map { it.replaceWithVariables(localEnvs) }.toList()
-            }.joinToString("\n")
-            val targetFile = File(targetFolder, newName)
-            targetFile.writeText(content)
-            println("Target file: ${targetFile.absolutePath}")
-        }
-        else -> {
-            val folder = File(targetFolder, newName)
-            println("Target folder: ${folder.absolutePath}")
-            folder.mkdirs()
-            listFiles() ?.forEach { fileOrFolder ->
-                fileOrFolder.handleTemplate(folder, localEnvs)
-            }
-        }
-    }
-}
-
-templatesFolders.forEach { folderOrFile ->
-    folderOrFile.handleTemplate(outputFolder, envs)
-}

BoostsInfoBot/src/main/kotlin/BoostsInfo.kt

@@ -4,13 +4,13 @@ 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.get.getUserChatBoosts
-import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.extensions.api.send.*
 import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatBoostUpdated
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatShared
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
-import dev.inmo.tgbotapi.extensions.utils.types.buttons.flatReplyKeyboard
+import dev.inmo.tgbotapi.extensions.utils.types.buttons.*
-import dev.inmo.tgbotapi.extensions.utils.types.buttons.requestChannelButton
+import dev.inmo.tgbotapi.types.chat.member.ChatCommonAdministratorRights
 import dev.inmo.tgbotapi.types.request.RequestId
 import dev.inmo.tgbotapi.utils.regular
 import korlibs.time.DateFormat
@@ -52,21 +52,14 @@ suspend fun main(args: Array<String>) {
         }
 
         onChatShared(initialFilter = { it.chatEvent.requestId == requestChatId }) {
-            val boostsInfoContrainer = runCatching {
+            val boosts = getUserChatBoosts(it.chatEvent.chatId, it.chat.id)
-                getUserChatBoosts(it.chatEvent.chatId, it.chat.id)
+            reply(
-            }.getOrNull()
+                it
-
+            ) {
-            reply(it) {
+                boosts.boosts.forEach {
-                when {
-                    boostsInfoContrainer == null -> +"Unable to take info about boosts in shared chat"
-                    boostsInfoContrainer.boosts.isEmpty() -> +"There is no any boosts in passed chat"
-                    else -> {
-                        boostsInfoContrainer.boosts.forEach {
                     regular("Boost added: ${DateFormat.FORMAT1.format(it.addDate.asDate)}; Boost expire: ${DateFormat.FORMAT1.format(it.expirationDate.asDate)}; Unformatted: $it") + "\n"
                 }
             }
         }
-            }
-        }
     }.join()
 }

BusinessConnectionsBot/README.md

@@ -1,9 +0,0 @@
-# BusinessConnectionBotBot
-
-When bot connected or disconnected to the business chat, it will notify this chat
-
-## Launch
-
-```bash
-../gradlew run --args="BOT_TOKEN"
-```

BusinessConnectionsBot/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="BusinessConnectionsBotKt"
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-}

BusinessConnectionsBot/src/main/kotlin/BusinessConnectionsBot.kt

@@ -1,487 +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.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.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()
-    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 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")
-        }
-
-        onContentMessage {
-            it.ifBusinessContentMessage { businessContentMessage ->
-                if (businessContentMessage.content.textContentOrNull() ?.text ?.startsWith("/pin") == true) {
-                    businessContentMessage.replyTo ?.ifAccessibleMessage {
-                        pinChatMessage(it)
-                        return@ifBusinessContentMessage
-                    }
-                }
-                if (businessContentMessage.content.textContentOrNull() ?.text ?.startsWith("/unpin") == true) {
-                    businessContentMessage.replyTo ?.ifAccessibleMessage {
-                        unpinChatMessage(it)
-                        return@ifBusinessContentMessage
-                    }
-                }
-                val sent = execute(it.content.createResend(businessContentMessage.from.id))
-                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}")
-                            }
-                        }
-                    )
-                }
-            }
-        }
-        onEditedContentMessage {
-            it.ifBusinessContentMessage { businessContentMessage ->
-                val sent = execute(businessContentMessage.content.createResend(businessContentMessage.from.id))
-                if (businessContentMessage.sentByBusinessConnectionOwner) {
-                    reply(sent, "You have edited this message in the ${businessContentMessage.businessConnectionId.string} related chat")
-                } else {
-                    reply(sent, "User have edited this message to you in the ${businessContentMessage.businessConnectionId.string} related chat")
-                }
-            }
-        }
-        onBusinessMessagesDeleted {
-            var businessConnectionOwnerChat = businessConnectionsChatsMutex.withLock {
-                businessConnectionsChats[it.businessConnectionId]
-            }
-            if (businessConnectionOwnerChat == null) {
-                val businessConnection = getBusinessConnection(it.businessConnectionId)
-                businessConnectionsChatsMutex.withLock {
-                    businessConnectionsChats[businessConnection.businessConnectionId] = businessConnection.userChatId
-                }
-                businessConnectionOwnerChat = businessConnection.userChatId
-            }
-            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()
-}

ChatAvatarSetter/src/main/kotlin/ChatAvatarSetter.kt

@@ -5,9 +5,9 @@ import dev.inmo.tgbotapi.extensions.api.files.downloadFile
 import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onPhoto
+import dev.inmo.tgbotapi.extensions.utils.*
 import dev.inmo.tgbotapi.requests.abstracts.asMultipartFile
-import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.*
-import kotlinx.coroutines.Dispatchers
 
 suspend fun main(args: Array<String>) {
     val bot = telegramBot(args.first())

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/README.md

@@ -1,9 +0,0 @@
-# CustomBot
-
-This bot basically have no any useful behaviour, but you may customize it as a playground
-
-## Launch
-
-```bash
-../gradlew run --args="BOT_TOKEN"
-```

CustomBot/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="CustomBotKt"
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-}

CustomBot/src/main/kotlin/CustomBot.kt

@@ -1,100 +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.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.
- */
-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.IO),
-        testServer = isTestServer,
-        builder = {
-            includeMiddlewares {
-                addMiddleware {
-                    doOnRequestReturnResult { result, request, _ ->
-                        println("Result of $request:\n\n$result")
-                        null
-                    }
-                }
-            }
-        },
-        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)
-        }
-    }.second.join()
-}

DeepLinksBot/src/main/kotlin/DeepLinksBot.kt

@@ -1,11 +1,11 @@
+import dev.inmo.micro_utils.coroutines.subscribeSafelySkippingExceptions
 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.send.reply
 import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitDeepLinks
 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.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onDeepLink
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onText
 import dev.inmo.tgbotapi.extensions.utils.formatting.makeTelegramDeepLink
 import dev.inmo.tgbotapi.types.message.textsources.BotCommandTextSource
 

FSMBot/src/main/kotlin/SimpleFSMBot.kt

@@ -1,27 +1,22 @@
-import dev.inmo.micro_utils.coroutines.awaitFirst
+import dev.inmo.micro_utils.coroutines.AccumulatorFlow
-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.api.send.sendMessage
-import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitCommandMessage
+import dev.inmo.tgbotapi.extensions.behaviour_builder.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndFSMAndStartLongPolling
+import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.command
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
+import dev.inmo.tgbotapi.extensions.utils.extensions.parseCommandsWithParams
-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
+import dev.inmo.tgbotapi.extensions.utils.formatting.*
-import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
 import dev.inmo.tgbotapi.types.IdChatIdentifier
+import dev.inmo.tgbotapi.types.MessageThreadId
 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 dev.inmo.tgbotapi.utils.extensions.threadIdOrNull
-import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.*
-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,30 +48,19 @@ suspend fun main(args: Array<String>) {
                 +"Send me some content or " + botCommand("stop") + " if you want to stop sending"
             }
 
-            val contentMessage = firstOf(
+            val contentMessage = waitAnyContentMessage().filter { message ->
-                {
-                    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 content = contentMessage.content
 
+            when {
+                content is TextContent && content.parseCommandsWithParams().keys.contains("stop") -> StopState(it.context)
+                else -> {
                     execute(content.createResend(it.context))
                     it
                 }
+            }
+        }
         strictlyOn<StopState> {
             send(it.context) { +"You have stopped sending of content" }
 
@@ -88,17 +72,5 @@ suspend fun main(args: Array<String>) {
         ) {
             startChain(ExpectContentOrStopState(it.chat.id, it))
         }
-
-        onContentMessage(
-            {
-                it.content.textContentOrNull() ?.text == "/start"
-            }
-        ) {
-            startChain(ExpectContentOrStopState(it.chat.id, it.withContentOrNull() ?: return@onContentMessage))
-        }
-
-        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
-            println(it)
-        }
     }.second.join()
 }

FilesLoaderBot/src/main/kotlin/FilesLoaderBot.kt

@@ -2,17 +2,38 @@ import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.files.downloadFile
 import dev.inmo.tgbotapi.extensions.api.files.downloadFileToTemp
 import dev.inmo.tgbotapi.extensions.api.get.getFileAdditionalInfo
-import dev.inmo.tgbotapi.extensions.api.send.*
+import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.extensions.api.send.replyWithAnimation
+import dev.inmo.tgbotapi.extensions.api.send.replyWithAudio
+import dev.inmo.tgbotapi.extensions.api.send.replyWithDocument
+import dev.inmo.tgbotapi.extensions.api.send.replyWithMediaGroup
+import dev.inmo.tgbotapi.extensions.api.send.replyWithPhoto
+import dev.inmo.tgbotapi.extensions.api.send.replyWithSticker
+import dev.inmo.tgbotapi.extensions.api.send.replyWithVideo
+import dev.inmo.tgbotapi.extensions.api.send.replyWithVideoNote
+import dev.inmo.tgbotapi.extensions.api.send.replyWithVoice
+import dev.inmo.tgbotapi.extensions.api.send.withAction
 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.onMedia
 import dev.inmo.tgbotapi.requests.abstracts.asMultipartFile
-import dev.inmo.tgbotapi.types.actions.*
+import dev.inmo.tgbotapi.requests.send.SendAction
+import dev.inmo.tgbotapi.types.actions.BotAction
+import dev.inmo.tgbotapi.types.actions.TypingAction
 import dev.inmo.tgbotapi.types.media.TelegramMediaAudio
 import dev.inmo.tgbotapi.types.media.TelegramMediaDocument
 import dev.inmo.tgbotapi.types.media.TelegramMediaPhoto
 import dev.inmo.tgbotapi.types.media.TelegramMediaVideo
-import dev.inmo.tgbotapi.types.message.content.*
+import dev.inmo.tgbotapi.types.message.content.AnimationContent
+import dev.inmo.tgbotapi.types.message.content.AudioContent
+import dev.inmo.tgbotapi.types.message.content.DocumentContent
+import dev.inmo.tgbotapi.types.message.content.MediaGroupContent
+import dev.inmo.tgbotapi.types.message.content.PhotoContent
+import dev.inmo.tgbotapi.types.message.content.StickerContent
+import dev.inmo.tgbotapi.types.message.content.VideoContent
+import dev.inmo.tgbotapi.types.message.content.VideoNoteContent
+import dev.inmo.tgbotapi.types.message.content.VoiceContent
 import dev.inmo.tgbotapi.utils.filenameFromUrl
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -34,27 +55,13 @@ suspend fun main(args: Array<String>) {
             val content = it.content
             val pathedFile = bot.getFileAdditionalInfo(content.media)
             val outFile = File(directoryOrFile, pathedFile.filePath.filenameFromUrl)
-            withTypingAction(it.chat.id) {
             runCatching {
                 bot.downloadFile(content.media, outFile)
             }.onFailure {
                 it.printStackTrace()
             }.onSuccess { _ ->
                 reply(it, "Saved to ${outFile.absolutePath}")
-                }
+                withAction(it.chat.id, TypingAction) {
-            }.onSuccess { _ ->
-                val action = when (content) {
-                    is PhotoContent -> UploadPhotoAction
-                    is AnimationContent,
-                    is VideoContent -> UploadVideoAction
-                    is StickerContent -> ChooseStickerAction
-                    is MediaGroupContent<*> -> UploadPhotoAction
-                    is DocumentContent -> UploadDocumentAction
-                    is VoiceContent,
-                    is AudioContent -> RecordVoiceAction
-                    is VideoNoteContent -> UploadVideoNoteAction
-                }
-                withAction(it.chat.id, action) {
                     when (content) {
                         is PhotoContent -> replyWithPhoto(
                             it,

GetMeBot/src/main/kotlin/GetMeBot.kt

@@ -1,13 +1,15 @@
 import dev.inmo.kslog.common.KSLog
 import dev.inmo.kslog.common.LogLevel
 import dev.inmo.kslog.common.defaultMessageFormatter
+import dev.inmo.kslog.common.filter.filtered
 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
+import dev.inmo.tgbotapi.utils.DefaultKTgBotAPIKSLog
 
 /**
- * This is one of the easiest bots - it will just print information about itself
+ * This is one of the most easiest bot - it will just print information about itself
  */
 suspend fun main(vararg args: String) {
     val botToken = args.first()

GiveawaysBot/README.md

@@ -1,9 +0,0 @@
-# CustomBot
-
-Printing giveaways
-
-## Launch
-
-```bash
-../gradlew run --args="BOT_TOKEN"
-```

GiveawaysBot/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="GiveawaysBotKt"
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-}

GiveawaysBot/src/main/kotlin/GiveawaysBot.kt

@@ -1,57 +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.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-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 kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-
-/**
- * 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, testServer = isTestServer) {
-        // start here!!
-        val me = getMe()
-        println(me)
-
-        onGiveawayCreated {
-            println(it)
-        }
-
-        onGiveawayCompleted {
-            println(it)
-        }
-
-        onGiveawayWinners {
-            println(it)
-        }
-
-        onGiveawayContent {
-            println(it)
-        }
-
-//        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
-//            println(it)
-//        }
-    }.second.join()
-}

HelloBot/src/main/kotlin/HelloBot.kt

@@ -1,21 +1,23 @@
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
-import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.extensions.api.send.*
 import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onMentionWithAnyContent
 import dev.inmo.tgbotapi.extensions.utils.extensions.raw.sender_chat
-import dev.inmo.tgbotapi.extensions.utils.extensions.raw.text
 import dev.inmo.tgbotapi.extensions.utils.formatting.linkMarkdownV2
 import dev.inmo.tgbotapi.extensions.utils.formatting.textMentionMarkdownV2
+import dev.inmo.tgbotapi.extensions.utils.ifChannelChat
 import dev.inmo.tgbotapi.extensions.utils.ifFromChannelGroupContentMessage
 import dev.inmo.tgbotapi.types.chat.*
+import dev.inmo.tgbotapi.types.chat.GroupChat
+import dev.inmo.tgbotapi.types.chat.PrivateChat
+import dev.inmo.tgbotapi.types.chat.SupergroupChat
 import dev.inmo.tgbotapi.types.message.MarkdownV2
 import dev.inmo.tgbotapi.utils.PreviewFeature
 import dev.inmo.tgbotapi.utils.extensions.escapeMarkdownV2Common
-import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.*
-import kotlinx.coroutines.Dispatchers
 
 /**
  * The main purpose of this bot is just to answer "Oh, hi, " and add user mention here
@@ -26,35 +28,24 @@ suspend fun main(vararg args: String) {
 
     telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO)) {
         val me = getMe()
-        onContentMessage(
+        onMentionWithAnyContent(me) { message ->
-            initialFilter = initialFilter@{ it.text ?.contains(me.username ?.full ?: return@initialFilter false) == true }
+            val chat = message.chat
-        ) { message ->
+
             val answerText = when (val chat = message.chat) {
                 is PreviewChannelChat -> {
-                    val sender = message.sender_chat
+                    val answer = "Hi everybody in this channel \"${chat.title}\""
-                    val answer = "Hi everybody in this channel \"${chat.title}\"" + if (sender != null) {
+                    reply(message, answer, MarkdownV2)
-                        " and you, " + when (sender) {
+                    return@onMentionWithAnyContent
-                            is BusinessChat -> "business chat (wat) ${sender.original}"
-                            is PrivateChat -> "${sender.lastName} ${sender.firstName}"
-                            is GroupChat -> "group ${sender.title}"
-                            is ChannelChat ->  "channel ${sender.title}"
-                            is UnknownChatType -> "wat chat (${sender})"
-                        }
-                    } else {
-                        ""
-                    }
-                    reply(message, answer.escapeMarkdownV2Common(), MarkdownV2)
-                    return@onContentMessage
                 }
                 is PreviewPrivateChat -> {
                     reply(message, "Hi, " + "${chat.firstName} ${chat.lastName}".textMentionMarkdownV2(chat.id), MarkdownV2)
-                    return@onContentMessage
+                    return@onMentionWithAnyContent
                 }
                 is PreviewGroupChat -> {
-                    message.ifFromChannelGroupContentMessage<Unit> {
+                    message.ifFromChannelGroupContentMessage {
                         val answer = "Hi, ${it.senderChat.title}"
                         reply(message, answer, MarkdownV2)
-                        return@onContentMessage
+                        return@onMentionWithAnyContent
                     }
                     "Oh, hi, " + when (chat) {
                         is SupergroupChat -> (chat.username ?.username ?: getChat(chat).inviteLink) ?.let {
@@ -65,10 +56,6 @@ suspend fun main(vararg args: String) {
                         } ?: chat.title
                     }
                 }
-                is PreviewBusinessChat -> {
-                    reply(message, "Hi, " + "${chat.original.firstName} ${chat.original.lastName} (as business chat :) )".textMentionMarkdownV2(chat.original.id), MarkdownV2)
-                    return@onContentMessage
-                }
                 is UnknownChatType -> "Unknown :(".escapeMarkdownV2Common()
             }
             reply(

InlineQueriesBot/build.gradle

@@ -12,16 +12,14 @@ plugins {
     id "org.jetbrains.kotlin.multiplatform"
 }
 
+apply plugin: 'application'
+
+mainClassName="InlineQueriesBotKt"
+
 apply from: "$nativePartTemplate"
 
 kotlin {
-    jvm {
+    jvm()
-        binaries {
-            executable {
-                mainClass.set("InlineQueriesBotKt")
-            }
-        }
-    }
 
     sourceSets {
         commonMain {
@@ -29,9 +27,12 @@ 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.7'
+}
+

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
@@ -9,7 +9,6 @@ import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onDeepLi
 import dev.inmo.tgbotapi.requests.answers.InlineQueryResultsButton
 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.inlineQueryAnswerResultsLimit
 import dev.inmo.tgbotapi.utils.buildEntities
 
@@ -32,9 +31,9 @@ suspend fun doInlineQueriesBot(token: String) {
             answer(
                 it,
                 results = results.map { resultNumber ->
-                    val inlineQueryId = InlineQueryId(resultNumber.toString())
+                    val resultAsString = resultNumber.toString()
                     InlineQueryResultArticle(
-                        inlineQueryId,
+                        resultAsString,
                         "Title $resultNumber",
                         InputTextMessageContent(
                             buildEntities {
@@ -59,7 +58,7 @@ suspend fun doInlineQueriesBot(token: String) {
             reply(message, deepLink)
         }
 
-        allUpdatesFlow.subscribeLoggingDropExceptions(scope = this) {
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
             println(it)
         }
 

InlineQueriesBot/src/jvmMain/kotlin/InlineQueriesBot.kt

@@ -1,3 +1,5 @@
+import dev.inmo.micro_utils.common.MPPFile
+
 suspend fun main(args: Array<String>) {
     doInlineQueriesBot(args.first())
 }

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

@@ -1,27 +1,26 @@
-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.bot.ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.answers.answer
-import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
 import dev.inmo.tgbotapi.extensions.api.edit.edit
+import dev.inmo.tgbotapi.extensions.api.edit.editMessageText
+import dev.inmo.tgbotapi.extensions.api.edit.reply_markup.editMessageReplyMarkup
 import dev.inmo.tgbotapi.extensions.api.edit.text.editMessageText
-import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.extensions.api.send.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
+import dev.inmo.tgbotapi.extensions.behaviour_builder.*
 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.InlineQueries.InlineQueryResult.InlineQueryResultArticle
 import dev.inmo.tgbotapi.types.InlineQueries.InputMessageContent.InputTextMessageContent
-import dev.inmo.tgbotapi.types.InlineQueryId
 import dev.inmo.tgbotapi.types.message.content.TextContent
-import dev.inmo.tgbotapi.utils.PreviewFeature
+import dev.inmo.tgbotapi.utils.*
-import dev.inmo.tgbotapi.utils.botCommand
+import kotlinx.coroutines.*
-import dev.inmo.tgbotapi.utils.regular
+
-import dev.inmo.tgbotapi.utils.row
+private const val nextPageData = "next"
-import kotlinx.coroutines.CoroutineScope
+private const val previousPageData = "previous"
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.currentCoroutineContext
 
 fun String.parsePageAndCount(): Pair<Int, Int>? {
     val (pageString, countString) = split(" ").takeIf { it.count() > 1 } ?: return null
@@ -45,9 +44,6 @@ fun InlineKeyboardBuilder.includePageButtons(page: Int, count: Int) {
             }
         }
     }
-    row {
-        copyTextButton("Command copy button", "/inline $page $count")
-    }
 
     row {
         if (page - 1 > 2) {
@@ -76,7 +72,6 @@ fun InlineKeyboardBuilder.includePageButtons(page: Int, count: Int) {
     }
 }
 
-@OptIn(PreviewFeature::class)
 suspend fun activateKeyboardsBot(
     token: String,
     print: (Any) -> Unit
@@ -87,13 +82,11 @@ suspend fun activateKeyboardsBot(
 
     bot.buildBehaviourWithLongPolling(CoroutineScope(currentCoroutineContext() + SupervisorJob())) {
         onCommandWithArgs("inline") { message, args ->
-            val numberArgs = args.mapNotNull { it.toIntOrNull() }
+            val numberOfPages = args.firstOrNull() ?.toIntOrNull() ?: 10
-            val numberOfPages = numberArgs.getOrNull(1) ?: numberArgs.firstOrNull() ?: 10
-            val page = numberArgs.firstOrNull()?.takeIf { numberArgs.size > 1 }?.coerceAtLeast(1) ?: 1
             reply(
                 message,
                 replyMarkup = inlineKeyboard {
-                    includePageButtons(page, numberOfPages)
+                    includePageButtons(1, numberOfPages)
                 }
             ) {
                 regular("Your inline keyboard with $numberOfPages pages")
@@ -138,14 +131,13 @@ 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() }
+            val count = it.query.removePrefix(page.toString()).dropWhile { !it.isDigit() }.takeWhile { it.isDigit() }.toIntOrNull() ?: return@onBaseInlineQuery
-                .toIntOrNull() ?: return@onBaseInlineQuery
 
             answer(
                 it,
                 results = listOf(
                     InlineQueryResultArticle(
-                        InlineQueryId(it.query),
+                        it.query,
                         "Send buttons",
                         InputTextMessageContent("It is sent via inline mode inline buttons"),
                         replyMarkup = inlineKeyboard {
@@ -171,7 +163,7 @@ suspend fun activateKeyboardsBot(
 
         setMyCommands(BotCommand("inline", "Creates message with pagination inline keyboard"))
 
-        allUpdatesFlow.subscribeLoggingDropExceptions(scope = this) {
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
             println(it)
         }
     }.join()

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

@@ -1,21 +1,7 @@
-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)

LinkPreviewsBot/src/main/kotlin/LinkPreviewsBot.kt

@@ -3,15 +3,24 @@ 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.chat.get.getChat
+import dev.inmo.tgbotapi.extensions.api.send.copyMessage
 import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.api.send.send
+import dev.inmo.tgbotapi.extensions.api.send.setMessageReaction
 import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatMessageReactionUpdatedByUser
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatMessageReactionsCountUpdated
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
 import dev.inmo.tgbotapi.extensions.utils.textLinkTextSourceOrNull
 import dev.inmo.tgbotapi.extensions.utils.uRLTextSourceOrNull
 import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
 import dev.inmo.tgbotapi.types.LinkPreviewOptions
+import dev.inmo.tgbotapi.types.chat.ExtendedChat
+import dev.inmo.tgbotapi.types.message.content.TextContent
 import dev.inmo.tgbotapi.types.message.content.TextedContent
+import dev.inmo.tgbotapi.types.reactions.Reaction
+import dev.inmo.tgbotapi.utils.customEmoji
 import dev.inmo.tgbotapi.utils.regular
 
 /**
@@ -32,17 +41,17 @@ suspend fun main(vararg args: String) {
     val bot = telegramBot(botToken)
 
     bot.buildBehaviourWithLongPolling {
-        onContentMessage { contentMessage ->
+        onContentMessage {
-            val url = contentMessage.withContentOrNull<TextedContent>() ?.let { message ->
+            val url = it.withContentOrNull<TextedContent>() ?.let {
-                message.content.textSources.firstNotNullOfOrNull {
+                it.content.textSources.firstNotNullOfOrNull {
                     it.textLinkTextSourceOrNull() ?.url ?: it.uRLTextSourceOrNull() ?.source
                 }
             } ?: null.apply {
-                reply(contentMessage) {
+                reply(it) {
                     regular("I am support only content with text contains url only")
                 }
             } ?: return@onContentMessage
-            contentMessage.withContentOrNull<TextedContent>() ?.let {
+            it.withContentOrNull<TextedContent>() ?.let {
                 send(
                     it.chat,
                     it.content.textSources,

LiveLocationsBot/src/main/kotlin/LiveLocationsBot.kt

@@ -1,15 +1,33 @@
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.EditLiveLocationInfo
+import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
+import dev.inmo.tgbotapi.extensions.api.edit.edit
 import dev.inmo.tgbotapi.extensions.api.edit.location.live.stopLiveLocation
 import dev.inmo.tgbotapi.extensions.api.handleLiveLocation
+import dev.inmo.tgbotapi.extensions.api.send.*
 import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitMessageDataCallbackQuery
+import dev.inmo.tgbotapi.extensions.behaviour_builder.oneOf
+import dev.inmo.tgbotapi.extensions.behaviour_builder.parallel
 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.utils.extensions.sameMessage
+import dev.inmo.tgbotapi.extensions.utils.formatting.linkMarkdownV2
+import dev.inmo.tgbotapi.extensions.utils.formatting.textMentionMarkdownV2
+import dev.inmo.tgbotapi.extensions.utils.ifFromChannelGroupContentMessage
 import dev.inmo.tgbotapi.extensions.utils.types.buttons.dataButton
 import dev.inmo.tgbotapi.extensions.utils.types.buttons.flatInlineKeyboard
+import dev.inmo.tgbotapi.types.chat.*
+import dev.inmo.tgbotapi.types.chat.GroupChat
+import dev.inmo.tgbotapi.types.chat.PrivateChat
+import dev.inmo.tgbotapi.types.chat.SupergroupChat
+import dev.inmo.tgbotapi.types.location.LiveLocation
+import dev.inmo.tgbotapi.types.message.MarkdownV2
 import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
+import dev.inmo.tgbotapi.types.message.content.LiveLocationContent
 import dev.inmo.tgbotapi.types.message.content.LocationContent
+import dev.inmo.tgbotapi.utils.PreviewFeature
+import dev.inmo.tgbotapi.utils.extensions.escapeMarkdownV2Common
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.FlowCollector
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -46,7 +64,7 @@ suspend fun main(vararg args: String) {
                 handleLiveLocation(
                     it.chat.id,
                     locationsFlow,
-                    sentMessageFlow = { currentMessageState.emit(it) },
+                    sentMessageFlow = FlowCollector { currentMessageState.emit(it) }
                 )
             }
 

MemberUpdatedWatcherBot/README.md

@@ -1,10 +0,0 @@
-# MemberUpdatedWatcherBot
-
-This bot will watch for some ChatMemberUpdated events using new extensions from 18.0.0
-
-
-## Launch
-
-```bash
-../gradlew run --args="BOT_TOKEN"
-```

MemberUpdatedWatcherBot/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="MemberUpdatedWatcherKt"
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-}

MemberUpdatedWatcherBot/src/main/kotlin/MemberUpdatedWatcher.kt

@@ -1,98 +0,0 @@
-import dev.inmo.kslog.common.*
-import dev.inmo.tgbotapi.extensions.api.*
-import dev.inmo.tgbotapi.extensions.api.bot.*
-import dev.inmo.tgbotapi.extensions.api.send.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.filters.chatMemberGotRestrictedFilter
-import dev.inmo.tgbotapi.extensions.behaviour_builder.filters.chatMemberGotRestrictionsChangedFilter
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.utils.*
-import dev.inmo.tgbotapi.extensions.utils.*
-import dev.inmo.tgbotapi.types.chat.member.*
-import dev.inmo.tgbotapi.utils.*
-
-
-@OptIn(PreviewFeature::class)
-suspend fun main(args: Array<String>) {
-    val token = args.first()
-
-    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 internalLogger = KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-        println(defaultMessageFormatter(level, tag ?: "ChatMemberUpdates", message, throwable))
-    }
-
-    val bot = telegramBot(token)
-
-    bot.buildBehaviourWithLongPolling {
-        val me = getMe()
-        val filterSelfUpdates = SimpleFilter<ChatMemberUpdated> {
-            it.member.id == me.id
-        }
-
-        // This bot updates
-        onChatMemberJoined(initialFilter = filterSelfUpdates) {
-            internalLogger.i("Bot was added to chat")
-            send(it.chat.id, "I was added to chat. Please grant me admin permissions to make me able to watch other users' events")
-        }
-
-        onChatMemberGotPromoted(initialFilter = filterSelfUpdates) {
-            internalLogger.i("Bot was granted admin permissions")
-            send(it.chat.id, "I was promoted to admin. I now can watch other users' events")
-        }
-
-        onChatMemberGotDemoted(initialFilter = filterSelfUpdates) {
-            internalLogger.i("Admin permissions were revoked")
-            send(it.chat.id, "I'm no longer an admin. Admin permissions are required to watch other users' events")
-        }
-
-        // All users updates
-        onChatMemberJoined {
-            val member = it.member
-            internalLogger.i("${member.firstName} joined the chat: ${it.oldChatMemberState::class.simpleName} => ${it.newChatMemberState::class.simpleName}")
-            send(it.chat.id, "Welcome ${member.firstName}")
-        }
-
-        onChatMemberLeft {
-            val member = it.member
-            internalLogger.i("${member.firstName} left the chat: ${it.oldChatMemberState::class.simpleName} => ${it.newChatMemberState::class.simpleName}")
-            send(it.chat.id, "Goodbye ${member.firstName}")
-        }
-
-        onChatMemberGotPromoted {
-            val newState = it.newChatMemberState.administratorChatMemberOrThrow()
-            internalLogger.i("${newState.user.firstName} got promoted to ${newState.customTitle ?: "Admin"}: ${it.oldChatMemberState::class.simpleName} => ${it.newChatMemberState::class.simpleName}")
-            send(it.chat.id, "${newState.user.firstName} is now an ${newState.customTitle ?: "Admin"}")
-        }
-
-        onChatMemberGotDemoted {
-            val member = it.member
-            internalLogger.i("${member.firstName} got demoted: ${it.oldChatMemberState::class.simpleName} => ${it.newChatMemberState::class.simpleName}")
-            send(it.chat.id, "${member.firstName} is now got demoted back to member")
-        }
-
-        onChatMemberGotPromotionChanged {
-            val member = it.member
-            val message = "${member.firstName} has the permissions changed: ${it.oldChatMemberState::class.simpleName} => ${it.newChatMemberState::class.simpleName}"
-            internalLogger.i(message)
-            send(it.chat.id, message)
-        }
-
-        onChatMemberUpdated(
-            initialFilter = chatMemberGotRestrictedFilter + chatMemberGotRestrictionsChangedFilter,
-        ) {
-            val member = it.member
-            val message = "${member.firstName} has the permissions changed: ${it.oldChatMemberState::class.simpleName} => ${it.newChatMemberState::class.simpleName}"
-            internalLogger.i(message)
-            send(it.chat.id, message)
-        }
-    }.join()
-}

PollsBot/src/main/kotlin/PollsBot.kt

@@ -1,78 +1,58 @@
-import dev.inmo.kslog.common.KSLog
+import com.benasher44.uuid.uuid4
-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.setMyCommands
+import dev.inmo.tgbotapi.extensions.api.bot.getMe
-import dev.inmo.tgbotapi.extensions.api.send.polls.sendQuizPoll
+import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
+import dev.inmo.tgbotapi.extensions.api.send.*
 import dev.inmo.tgbotapi.extensions.api.send.polls.sendRegularPoll
-import dev.inmo.tgbotapi.extensions.api.send.send
 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.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onPollAnswer
+import dev.inmo.tgbotapi.extensions.utils.extensions.raw.sender_chat
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onPollUpdates
+import dev.inmo.tgbotapi.extensions.utils.formatting.linkMarkdownV2
-import dev.inmo.tgbotapi.extensions.utils.customEmojiTextSourceOrNull
+import dev.inmo.tgbotapi.extensions.utils.formatting.textMentionMarkdownV2
-import dev.inmo.tgbotapi.extensions.utils.extensions.parseCommandsWithArgsSources
+import dev.inmo.tgbotapi.extensions.utils.ifChannelChat
-import dev.inmo.tgbotapi.types.BotCommand
+import dev.inmo.tgbotapi.extensions.utils.ifFromChannelGroupContentMessage
+import dev.inmo.tgbotapi.types.ChatId
 import dev.inmo.tgbotapi.types.IdChatIdentifier
-import dev.inmo.tgbotapi.types.PollId
+import dev.inmo.tgbotapi.types.PollIdentifier
 import dev.inmo.tgbotapi.types.ReplyParameters
-import dev.inmo.tgbotapi.types.polls.InputPollOption
+import dev.inmo.tgbotapi.types.chat.*
+import dev.inmo.tgbotapi.types.chat.GroupChat
+import dev.inmo.tgbotapi.types.chat.PrivateChat
+import dev.inmo.tgbotapi.types.chat.SupergroupChat
+import dev.inmo.tgbotapi.types.message.MarkdownV2
+import dev.inmo.tgbotapi.types.polls.Poll
 import dev.inmo.tgbotapi.types.polls.PollAnswer
-import dev.inmo.tgbotapi.utils.buildEntities
+import dev.inmo.tgbotapi.types.polls.PollOption
-import dev.inmo.tgbotapi.utils.customEmoji
+import dev.inmo.tgbotapi.types.polls.RegularPoll
-import dev.inmo.tgbotapi.utils.regular
+import dev.inmo.tgbotapi.utils.PreviewFeature
-import dev.inmo.tgbotapi.utils.underline
+import dev.inmo.tgbotapi.utils.extensions.escapeMarkdownV2Common
-import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.*
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
-import kotlin.random.Random
 
 /**
  * This bot will answer with anonymous or public poll and send message on
- * any update.
+ * updates of any of it.
  * 
  * * Use `/anonymous` to take anonymous regular poll
  * * Use `/public` to take public regular poll
  */
+@OptIn(PreviewFeature::class)
 suspend fun main(vararg args: String) {
     val botToken = args.first()
-    val isDebug = args.any { it == "debug" }
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
 
     telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO)) {
-        val pollToChat = mutableMapOf<PollId, IdChatIdentifier>()
+        val me = getMe()
+
+        val pollToChat = mutableMapOf<PollIdentifier, IdChatIdentifier>()
         val pollToChatMutex = Mutex()
 
-        onCommand("anonymous", requireOnlyCommandInMessage = false) {
+        onCommand("anonymous") {
-            val customEmoji = it.content.parseCommandsWithArgsSources()
-                .toList()
-                .firstOrNull { it.first.command == "anonymous" }
-                ?.second
-                ?.firstNotNullOfOrNull { it.customEmojiTextSourceOrNull() }
             val sentPoll = sendRegularPoll(
-                it.chat.id,
+                it.chat,
-                buildEntities {
+                "Test regular anonymous poll",
-                    regular("Test regular anonymous poll")
-                    if (customEmoji != null) {
-                        customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
-                    }
-                },
                 (1 .. 10).map {
-                    InputPollOption {
+                    it.toString()
-                        regular(it.toString()) + " "
-                        if (customEmoji != null) {
-                            customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
-                        }
-                    }
                 },
                 isAnonymous = true,
                 replyParameters = ReplyParameters(it)
@@ -82,27 +62,12 @@ suspend fun main(vararg args: String) {
             }
         }
 
-        onCommand("public", requireOnlyCommandInMessage = false) {
+        onCommand("public") {
-            val customEmoji = it.content.parseCommandsWithArgsSources()
-                .toList()
-                .firstOrNull { it.first.command == "public" }
-                ?.second
-                ?.firstNotNullOfOrNull { it.customEmojiTextSourceOrNull() }
             val sentPoll = sendRegularPoll(
-                it.chat.id,
+                it.chat,
-                buildEntities {
+                "Test regular anonymous poll",
-                    regular("Test regular non anonymous poll")
-                    if (customEmoji != null) {
-                        customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
-                    }
-                },
                 (1 .. 10).map {
-                    InputPollOption {
+                    it.toString()
-                        regular(it.toString()) + " "
-                        if (customEmoji != null) {
-                            customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
-                        }
-                    }
                 },
                 isAnonymous = false,
                 replyParameters = ReplyParameters(it)
@@ -112,44 +77,6 @@ suspend fun main(vararg args: String) {
             }
         }
 
-        onCommand("quiz", requireOnlyCommandInMessage = false) {
-            val customEmoji = it.content.parseCommandsWithArgsSources()
-                .toList()
-                .firstOrNull { it.first.command == "quiz" }
-                ?.second
-                ?.firstNotNullOfOrNull { it.customEmojiTextSourceOrNull() }
-            val correctAnswer = Random.nextInt(10)
-            val sentPoll = sendQuizPoll(
-                it.chat.id,
-                questionEntities = buildEntities {
-                    regular("Test quiz poll")
-                    if (customEmoji != null) {
-                        customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
-                    }
-                },
-                (1 .. 10).map {
-                    InputPollOption {
-                        regular(it.toString()) + " "
-                        if (customEmoji != null) {
-                            customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
-                        }
-                    }
-                },
-                isAnonymous = false,
-                replyParameters = ReplyParameters(it),
-                correctOptionId = correctAnswer,
-                explanationTextSources = buildEntities {
-                    regular("Random solved it to be ") + underline((correctAnswer + 1).toString()) + " "
-                    if (customEmoji != null) {
-                        customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
-                    }
-                }
-            )
-            pollToChatMutex.withLock {
-                pollToChat[sentPoll.content.poll.id] = sentPoll.chat.id
-            }
-        }
-
         onPollAnswer {
             val chatId = pollToChat[it.pollId] ?: return@onPollAnswer
 
@@ -168,12 +95,6 @@ suspend fun main(vararg args: String) {
             }
         }
 
-        setMyCommands(
-            BotCommand("anonymous", "Create anonymous regular poll"),
-            BotCommand("public", "Create non anonymous regular poll"),
-            BotCommand("quiz", "Create quiz poll with random right answer"),
-        )
-
         allUpdatesFlow.subscribeSafelyWithoutExceptions(this) { println(it) }
     }.second.join()
 }

RandomFileSenderBot/build.gradle

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

ReactionsInfoBot/src/main/kotlin/ReactionsInfoBot.kt

@@ -6,6 +6,7 @@ import dev.inmo.tgbotapi.bot.ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
 import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.api.send.setMessageReaction
+import dev.inmo.tgbotapi.extensions.api.send.setMessageReactions
 import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatMessageReactionUpdatedByUser
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatMessageReactionsCountUpdated
@@ -48,7 +49,6 @@ suspend fun main(vararg args: String) {
                     when (it) {
                         is Reaction.CustomEmoji -> regular("• ") + customEmoji(it.customEmojiId) + regular("(customEmojiId: ${it.customEmojiId})")
                         is Reaction.Emoji -> regular("• ${it.emoji}")
-                        is Reaction.Paid -> regular("• Some paid reaction")
                         is Reaction.Unknown -> regular("• Unknown emoji ($it)")
                     }
                     regular("\n")

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

@@ -1,36 +1,27 @@
-import dev.inmo.kslog.common.KSLog
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-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.bot.ktor.telegramBot
+import dev.inmo.tgbotapi.extensions.api.send.*
+import dev.inmo.tgbotapi.extensions.api.send.media.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.filters.CommonMessageFilterExcludeMediaGroups
 import dev.inmo.tgbotapi.extensions.behaviour_builder.filters.MessageFilterByChat
-import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
+import dev.inmo.tgbotapi.extensions.utils.shortcuts.*
-import dev.inmo.tgbotapi.extensions.utils.possiblyWithEffectMessageOrNull
-import dev.inmo.tgbotapi.extensions.utils.shortcuts.executeUnsafe
 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.types.quoteEntitiesField
 import dev.inmo.tgbotapi.utils.extensions.threadIdOrNull
-import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.*
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.currentCoroutineContext
 
 suspend fun activateResenderBot(
     token: String,
     print: (Any) -> Unit
 ) {
-    telegramBotWithBehaviourAndLongPolling(
+    telegramBotWithBehaviourAndLongPolling(token, scope = CoroutineScope(currentCoroutineContext() + SupervisorJob())) {
-        token,
-        scope = CoroutineScope(currentCoroutineContext() + SupervisorJob()),
-    ) {
         onContentMessage(
             subcontextUpdatesFilter = MessageFilterByChat,
-            initialFilter = { it !is BusinessContentMessage<*> || !it.sentByBusinessConnectionOwner }
         ) {
             val chat = it.chat
 
@@ -46,8 +37,7 @@ suspend fun activateResenderBot(
                                 entities = quote ?.textSources ?: emptyList(),
                                 quotePosition = quote ?.position
                             )
-                        },
+                        }
-                        effectId = it.possiblyWithEffectMessageOrNull()?.effectId
                     )
                 ) {
                     it.forEach(print)
@@ -57,7 +47,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:2.3.7'
 }

RightsChangerBot/src/main/kotlin/RightsChanger.kt

@@ -16,9 +16,7 @@ import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.api.send.send
 import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
 import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithFSMAndStartLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitChatSharedEventsMessages
+import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitCommandMessage
-import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitUserSharedEventsMessages
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onMessageDataCallbackQuery
 import dev.inmo.tgbotapi.extensions.utils.*
@@ -29,12 +27,12 @@ import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
 import dev.inmo.tgbotapi.types.chat.ChannelChat
 import dev.inmo.tgbotapi.types.chat.ChatPermissions
 import dev.inmo.tgbotapi.types.chat.PublicChat
-import dev.inmo.tgbotapi.types.chat.member.AdministratorChatMember
+import dev.inmo.tgbotapi.types.chat.member.*
-import dev.inmo.tgbotapi.types.chat.member.ChatCommonAdministratorRights
 import dev.inmo.tgbotapi.types.commands.BotCommandScope
 import dev.inmo.tgbotapi.types.message.abstracts.AccessibleMessage
 import dev.inmo.tgbotapi.types.request.RequestId
 import dev.inmo.tgbotapi.utils.*
+import dev.inmo.tgbotapi.utils.mention
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.mapNotNull
@@ -54,7 +52,6 @@ sealed interface UserRetrievingStep : State {
     ) : UserRetrievingStep
 }
 
-@OptIn(PreviewFeature::class)
 suspend fun main(args: Array<String>) {
     val botToken = args.first()
 
@@ -70,7 +67,7 @@ suspend fun main(args: Array<String>) {
 
     val bot = telegramBot(botToken)
 
-    val allowedAdmin = ChatId(RawChatId(args[1].toLong()))
+    val allowedAdmin = ChatId(args[1].toLong())
 
     fun Boolean?.allowedSymbol() = when (this) {
         true -> "✅"
@@ -106,7 +103,7 @@ suspend fun main(args: Array<String>) {
 
     suspend fun BehaviourContext.getUserChatPermissions(chatId: ChatId, userId: UserId): ChatPermissions? {
         val chatMember = getChatMember(chatId, userId)
-        return chatMember.restrictedMemberChatMemberOrNull() ?: chatMember.whenMemberChatMember {
+        return chatMember.restrictedChatMemberOrNull() ?: chatMember.whenMemberChatMember {
             getChat(chatId).extendedGroupChatOrNull() ?.permissions
         }
     }
@@ -227,6 +224,7 @@ suspend fun main(args: Array<String>) {
             }
         ) {
             val replyMessage = it.replyTo
+            val usernameInText = it.content.textSources.firstNotNullOfOrNull { it.mentionTextSourceOrNull() } ?.username
             val userInReply = replyMessage?.fromUserMessageOrNull()?.user?.id ?: return@onCommand
 
             if (replyMessage is AccessibleMessage) {
@@ -379,10 +377,11 @@ suspend fun main(args: Array<String>) {
             initialFilter = { it.user.id == allowedAdmin }
         ) {
             val (channelIdString, userIdString) = it.data.split(" ").drop(1)
-            val channelId = ChatId(RawChatId(channelIdString.toLong()))
+            val channelId = ChatId(channelIdString.toLong())
-            val userId = ChatId(RawChatId(userIdString.toLong()))
+            val userId = ChatId(userIdString.toLong())
             val chatMember = getChatMember(channelId, userId)
             val asAdmin = chatMember.administratorChatMemberOrNull()
+            val asMember = chatMember.memberChatMemberOrNull()
 
             val realData = it.data.takeWhile { it != ' ' }
 
@@ -505,6 +504,7 @@ suspend fun main(args: Array<String>) {
         strictlyOn<UserRetrievingStep.RetrievingChatInfoDoneState> { state ->
             val chatMember = getChatMember(state.channelId, state.userId).administratorChatMemberOrNull()
             if (chatMember == null) {
+
                 return@strictlyOn null
             }
             send(

StarTransactionsBot/README.md

@@ -1,9 +0,0 @@
-# StarTransactionsBot
-
-This bot basically have no any useful behaviour, but you may customize it as a playground
-
-## Launch
-
-```bash
-../gradlew run --args="BOT_TOKEN"
-```

StarTransactionsBot/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="StarTransactionsBotKt"
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-}

StarTransactionsBot/src/main/kotlin/StarTransactionsBot.kt

@@ -1,184 +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.answers.payments.answerPreCheckoutQueryOk
-import dev.inmo.tgbotapi.extensions.api.edit.edit
-import dev.inmo.tgbotapi.extensions.api.files.downloadFileToTemp
-import dev.inmo.tgbotapi.extensions.api.get.getStarTransactions
-import dev.inmo.tgbotapi.extensions.api.send.reply
-import dev.inmo.tgbotapi.extensions.api.send.send
-import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
-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.RawChatId
-import dev.inmo.tgbotapi.types.UserId
-import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
-import dev.inmo.tgbotapi.types.files.*
-import dev.inmo.tgbotapi.types.media.TelegramPaidMediaPhoto
-import dev.inmo.tgbotapi.types.media.TelegramPaidMediaVideo
-import dev.inmo.tgbotapi.types.media.toTelegramPaidMediaPhoto
-import dev.inmo.tgbotapi.types.media.toTelegramPaidMediaVideo
-import dev.inmo.tgbotapi.types.message.content.TextContent
-import dev.inmo.tgbotapi.types.message.textsources.TextSourcesList
-import dev.inmo.tgbotapi.types.payments.LabeledPrice
-import dev.inmo.tgbotapi.types.payments.stars.StarTransaction
-import dev.inmo.tgbotapi.types.request.RequestId
-import dev.inmo.tgbotapi.utils.bold
-import dev.inmo.tgbotapi.utils.buildEntities
-import dev.inmo.tgbotapi.utils.regular
-import dev.inmo.tgbotapi.utils.row
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-
-/**
- * An example bot that interacts with Telegram Stars API (used for payments)
- */
-suspend fun main(vararg args: String) {
-    val botToken = args.first()
-    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" }
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
-
-    telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO), testServer = isTestServer) {
-        val payload = "sample payload"
-        command("start") {
-            reply(
-                it,
-                price = LabeledPrice("1", 1L),
-                title = "Sample",
-                description = "Sample description",
-                payload = payload,
-                replyMarkup = flatInlineKeyboard {
-                    payButton("Pay")
-                },
-            )
-        }
-
-        onPreCheckoutQuery(initialFilter = { it.invoicePayload == payload }) {
-            answerPreCheckoutQueryOk(it)
-        }
-
-        val transactionsDataPrefix = "getStarTransactions"
-        fun buildTransactionsData(offset: Int, limit: Int = 10) = "$transactionsDataPrefix $offset $limit"
-        fun parseTransactionsData(data: String): Pair<Int, Int> = data.split(" ").drop(1).let {
-            it.first().toInt() to it.last().toInt()
-        }
-        suspend fun buildStarTransactionsPage(offset: Int, limit: Int = 10): Pair<TextSourcesList, InlineKeyboardMarkup> {
-            val transactions = getStarTransactions(offset, limit)
-            return buildEntities {
-                transactions.transactions.forEach {
-                    regular("Transaction Id: ") + bold(it.id.string) + "\n"
-                    regular("Date: ") + bold(it.date.asDate.toStringDefault()) + "\n"
-                    regular("Amount: ") + bold(it.amount.toString()) + "\n"
-                    when (it) {
-                        is StarTransaction.Incoming -> {
-                            regular("Type: ") + bold("incoming") + "\n"
-                            regular("Partner: ") + bold(it.partner.type) + "\n"
-                        }
-                        is StarTransaction.Outgoing -> {
-                            regular("Type: ") + bold("outgoing") + "\n"
-                            regular("Partner: ") + bold(it.partner.type) + "\n"
-                        }
-                        is StarTransaction.Unknown -> {
-                            regular("Type: ") + bold("unknown") + "\n"
-                            regular("Partner: ") + bold(it.partner.type) + "\n"
-                        }
-                    }
-                }
-            } to inlineKeyboard {
-                row {
-                    val prevOffset = (offset - limit).coerceAtLeast(0)
-                    if (prevOffset < offset) {
-                        dataButton("<", buildTransactionsData(prevOffset, limit))
-                    }
-                    val nextOffset = (offset + limit)
-                    dataButton(">", buildTransactionsData(nextOffset, limit))
-                }
-            }
-        }
-
-        onCommand("transactions", initialFilter = { it.sameChat(adminUserId) }) {
-            val (text, keyboard) = buildStarTransactionsPage(0)
-
-            reply(it, text, replyMarkup = keyboard)
-        }
-
-        onMessageDataCallbackQuery(Regex("$transactionsDataPrefix \\d+ \\d+")) {
-            val (offset, limit) = parseTransactionsData(it.data)
-            val (text, keyboard) = buildStarTransactionsPage(offset, limit)
-            edit(
-                it.message.withContentOrNull<TextContent>() ?: return@onMessageDataCallbackQuery,
-                text,
-                replyMarkup = keyboard,
-            )
-        }
-
-        onVisualGalleryMessages {
-            send(
-                it.chat,
-                1,
-                it.content.group.mapNotNull {
-                    val file = downloadFileToTemp(it.content.media)
-                    when (it.content.media) {
-                        is VideoFile -> {
-                            TelegramPaidMediaVideo(
-                                file.asMultipartFile()
-                            )
-                        }
-                        is PhotoSize -> {
-                            TelegramPaidMediaPhoto(
-                                file.asMultipartFile()
-                            )
-                        }
-                        else -> null
-                    }
-                },
-                it.content.textSources,
-                showCaptionAboveMedia = true
-            )
-        }
-
-        onPhoto {
-            send(
-                it.chat,
-                1,
-                listOf(it.content.media.toTelegramPaidMediaPhoto())
-            )
-        }
-
-        onVideo {
-            send(
-                it.chat,
-                1,
-                listOf(it.content.media.toTelegramPaidMediaVideo())
-            )
-        }
-
-        onPaidMediaInfoContent {
-            println(it)
-        }
-
-        onRefundedPayment {
-            reply(
-                it,
-                "Received your refund: ${it.chatEvent.payment}"
-            )
-        }
-
-        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) { println(it) }
-    }.second.join()
-}

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

@@ -1,25 +1,29 @@
 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
+import dev.inmo.tgbotapi.bot.ktor.telegramBot
-import dev.inmo.tgbotapi.extensions.api.get.getStickerSet
+import dev.inmo.tgbotapi.extensions.api.get.*
-import dev.inmo.tgbotapi.extensions.api.get.getStickerSetOrNull
+import dev.inmo.tgbotapi.extensions.api.send.*
-import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.extensions.behaviour_builder.*
-import dev.inmo.tgbotapi.extensions.api.send.withTypingAction
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
+import dev.inmo.tgbotapi.types.StickerFormat
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSticker
-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.*
-import dev.inmo.tgbotapi.types.message.textsources.regularTextSource
+import dev.inmo.tgbotapi.types.stickers.AnimatedStickerSet
-import dev.inmo.tgbotapi.types.message.textsources.separateForText
+import dev.inmo.tgbotapi.types.stickers.CustomEmojiSimpleStickerSet
+import dev.inmo.tgbotapi.types.stickers.CustomEmojiStickerSet
+import dev.inmo.tgbotapi.types.stickers.CustomEmojiVideoStickerSet
+import dev.inmo.tgbotapi.types.stickers.MaskSimpleStickerSet
+import dev.inmo.tgbotapi.types.stickers.MaskStickerSet
+import dev.inmo.tgbotapi.types.stickers.MaskVideoStickerSet
+import dev.inmo.tgbotapi.types.stickers.RegularSimpleStickerSet
+import dev.inmo.tgbotapi.types.stickers.RegularStickerSet
+import dev.inmo.tgbotapi.types.stickers.RegularVideoStickerSet
 import dev.inmo.tgbotapi.types.stickers.StickerSet
+import dev.inmo.tgbotapi.types.stickers.UnknownStickerSet
 import dev.inmo.tgbotapi.utils.bold
 import dev.inmo.tgbotapi.utils.buildEntities
-import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.*
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.currentCoroutineContext
 
 fun StickerSet?.buildInfo() = buildEntities {
     if (this@buildInfo == null) {
@@ -27,6 +31,12 @@ fun StickerSet?.buildInfo() = buildEntities {
     } else {
         bold("StickerSet name: ") + "${name}\n"
         bold("StickerSet title: ") + "${title}\n"
+        bold("Sticker format: ") + when (stickerFormat) {
+            StickerFormat.Animated -> "Animated"
+            StickerFormat.Static -> "Static"
+            is StickerFormat.Unknown -> stickerFormat.type
+            StickerFormat.Video -> "Video"
+        } + "\n"
         bold(
             when (stickerType) {
                 StickerType.CustomEmoji -> "Custom emoji"
@@ -34,7 +44,7 @@ fun StickerSet?.buildInfo() = buildEntities {
                 StickerType.Regular -> "Regular"
                 is StickerType.Unknown -> "Unknown type \"${stickerType.type}\""
             }
-        ) + " sticker set with title " + bold(title) + " and name " + bold(name.string)
+        ) + " sticker set with title " + bold(title) + " and name " + bold(name)
     }
 }
 
@@ -62,7 +72,7 @@ suspend fun activateStickerInfoBot(
                 }.distinct().map {
                     getStickerSet(it)
                 }.distinct().flatMap {
-                    it.buildInfo() + regularTextSource("\n")
+                    it.buildInfo() + regular("\n")
                 }.separateForText().map { entities ->
                     reply(it, entities)
                 }
@@ -76,7 +86,7 @@ suspend fun activateStickerInfoBot(
             )
         }
 
-        allUpdatesFlow.subscribeLoggingDropExceptions(scope = this) {
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
             println(it)
         }
     }.join()

StickerSetHandler/src/main/kotlin/StickerSetHandlerBot.kt

@@ -1,6 +1,6 @@
 import dev.inmo.micro_utils.coroutines.runCatchingSafely
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
+import dev.inmo.tgbotapi.extensions.api.files.downloadFile
 import dev.inmo.tgbotapi.extensions.api.files.downloadFileToTemp
 import dev.inmo.tgbotapi.extensions.api.get.getStickerSet
 import dev.inmo.tgbotapi.extensions.api.send.reply
@@ -10,14 +10,11 @@ import dev.inmo.tgbotapi.extensions.api.stickers.deleteStickerSet
 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.onSticker
+import dev.inmo.tgbotapi.extensions.utils.extensions.raw.sticker
 import dev.inmo.tgbotapi.requests.abstracts.asMultipartFile
 import dev.inmo.tgbotapi.requests.stickers.InputSticker
-import dev.inmo.tgbotapi.types.StickerSetName
 import dev.inmo.tgbotapi.types.chat.Chat
-import dev.inmo.tgbotapi.types.files.CustomEmojiSticker
+import dev.inmo.tgbotapi.types.files.*
-import dev.inmo.tgbotapi.types.files.MaskSticker
-import dev.inmo.tgbotapi.types.files.RegularSticker
-import dev.inmo.tgbotapi.types.files.UnknownSticker
 import dev.inmo.tgbotapi.types.toChatId
 import dev.inmo.tgbotapi.utils.botCommand
 import kotlinx.coroutines.CoroutineScope
@@ -35,7 +32,7 @@ suspend fun main(args: Array<String>) {
         }
     ) {
         val me = getMe()
-        fun Chat.stickerSetName() = StickerSetName("s${id.chatId}_by_${me.username ?.withoutAt}")
+        fun Chat.stickerSetName() = "s${id.chatId}_by_${me.username ?.usernameWithoutAt}"
         onCommand("start") {
             reply(it) {
                 botCommand("delete") + " - to clear stickers"
@@ -58,19 +55,16 @@ suspend fun main(args: Array<String>) {
             val newSticker = when (sticker) {
                 is CustomEmojiSticker -> InputSticker.WithKeywords.CustomEmoji(
                     downloadFileToTemp(sticker.fileId).asMultipartFile(),
-                    sticker.stickerFormat,
                     listOf(sticker.emoji ?: "\uD83D\uDE0A"),
                     emptyList()
                 )
                 is MaskSticker -> InputSticker.Mask(
                     downloadFileToTemp(sticker.fileId).asMultipartFile(),
-                    sticker.stickerFormat,
                     listOf(sticker.emoji ?: "\uD83D\uDE0A"),
                     sticker.maskPosition
                 )
                 is RegularSticker -> InputSticker.WithKeywords.Regular(
                     downloadFileToTemp(sticker.fileId).asMultipartFile(),
-                    sticker.stickerFormat,
                     listOf(sticker.emoji ?: "\uD83D\uDE0A"),
                     emptyList()
                 )
@@ -79,25 +73,18 @@ suspend fun main(args: Array<String>) {
             runCatchingSafely {
                 getStickerSet(stickerSetName)
             }.onSuccess { stickerSet ->
-                runCatching {
                 addStickerToSet(it.chat.id.toChatId(), stickerSet.name, newSticker).also { _ ->
                     reply(
                         it,
                         getStickerSet(stickerSetName).stickers.last()
                     )
                 }
-                }.onFailure { exception ->
+            }.onFailure { _ ->
-                    exception.printStackTrace()
-                    reply(
-                        it,
-                        "Unable to add sticker in stickerset"
-                    )
-                }
-            }.onFailure { exception ->
                 createNewStickerSet(
                     it.chat.id.toChatId(),
-                    stickerSetName.string,
+                    stickerSetName,
                     "Sticker set by ${me.firstName}",
+                    it.content.media.stickerFormat,
                     listOf(
                         newSticker
                     ),
@@ -110,9 +97,5 @@ suspend fun main(args: Array<String>) {
                 }
             }
         }
-
-        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
-            println(it)
-        }
     }.second.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()
-}

TopicsHandling/src/main/kotlin/TopicsHandling.kt

@@ -1,8 +1,18 @@
 import com.benasher44.uuid.uuid4
+import dev.inmo.micro_utils.common.repeatOnFailure
 import dev.inmo.micro_utils.coroutines.runCatchingSafely
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
-import dev.inmo.tgbotapi.extensions.api.chat.forum.*
+import dev.inmo.tgbotapi.extensions.api.chat.forum.closeForumTopic
+import dev.inmo.tgbotapi.extensions.api.chat.forum.closeGeneralForumTopic
+import dev.inmo.tgbotapi.extensions.api.chat.forum.createForumTopic
+import dev.inmo.tgbotapi.extensions.api.chat.forum.deleteForumTopic
+import dev.inmo.tgbotapi.extensions.api.chat.forum.editForumTopic
+import dev.inmo.tgbotapi.extensions.api.chat.forum.editGeneralForumTopic
+import dev.inmo.tgbotapi.extensions.api.chat.forum.hideGeneralForumTopic
+import dev.inmo.tgbotapi.extensions.api.chat.forum.reopenForumTopic
+import dev.inmo.tgbotapi.extensions.api.chat.forum.reopenGeneralForumTopic
+import dev.inmo.tgbotapi.extensions.api.chat.forum.unhideGeneralForumTopic
 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

UserChatShared/src/main/kotlin/UserChatShared.kt

@@ -1,35 +1,23 @@
-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.runCatchingSafely
 import dev.inmo.tgbotapi.bot.ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
 import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
-import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.extensions.api.send.*
 import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatShared
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onUserShared
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onUsersShared
 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>) {
     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)
 
@@ -67,53 +55,35 @@ suspend fun main(args: Array<String>) {
         row {
             requestUserOrBotButton(
                 "\uD83D\uDC64/\uD83E\uDD16 (1)",
-                requestIdUserOrBot,
+                requestIdUserOrBot
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
             )
         }
         row {
             requestUserButton(
                 "\uD83D\uDC64☆ (1)",
                 requestIdUserNonPremium,
-                premiumUser = false,
+                premiumUser = false
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
             )
             requestUserButton(
                 "\uD83D\uDC64 (1)",
                 requestIdUserAny,
-                premiumUser = null,
+                premiumUser = null
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
             )
             requestUserButton(
                 "\uD83D\uDC64★ (1)",
                 requestIdUserPremium,
-                premiumUser = true,
+                premiumUser = true
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
             )
             requestBotButton(
                 "\uD83E\uDD16 (1)",
-                requestIdBot,
+                requestIdBot
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
             )
         }
         row {
             requestUsersOrBotsButton(
                 "\uD83D\uDC64/\uD83E\uDD16",
                 requestIdUsersOrBots,
-                maxCount = keyboardButtonRequestUserLimit.last,
+                maxCount = keyboardButtonRequestUserLimit.last
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
             )
         }
         row {
@@ -121,152 +91,101 @@ suspend fun main(args: Array<String>) {
                 "\uD83D\uDC64☆",
                 requestIdUsersNonPremium,
                 premiumUser = false,
-                maxCount = keyboardButtonRequestUserLimit.last,
+                maxCount = keyboardButtonRequestUserLimit.last
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
             )
             requestUsersButton(
                 "\uD83D\uDC64",
                 requestIdUsersAny,
                 premiumUser = null,
-                maxCount = keyboardButtonRequestUserLimit.last,
+                maxCount = keyboardButtonRequestUserLimit.last
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
             )
             requestUsersButton(
                 "\uD83D\uDC64★",
                 requestIdUsersPremium,
                 premiumUser = true,
-                maxCount = keyboardButtonRequestUserLimit.last,
+                maxCount = keyboardButtonRequestUserLimit.last
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
             )
             requestBotsButton(
                 "\uD83E\uDD16",
                 requestIdBots,
-                maxCount = keyboardButtonRequestUserLimit.last,
+                maxCount = keyboardButtonRequestUserLimit.last
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
             )
         }
         row {
             requestChatButton(
                 "\uD83D\uDDE3/\uD83D\uDC65",
-                requestIdAnyChat,
+                requestIdAnyChat
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
             )
         }
         row {
             requestChatButton(
                 "\uD83D\uDDE3",
                 requestIdChannel,
-                isChannel = true,
+                isChannel = true
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
             )
             requestChatButton(
                 "\uD83D\uDDE3\uD83D\uDD17",
                 requestIdPublicChannel,
                 isChannel = true,
-                isPublic = true,
+                isPublic = true
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
             )
             requestChatButton(
                 "\uD83D\uDDE3❌\uD83D\uDD17",
                 requestIdPrivateChannel,
                 isChannel = true,
-                isPublic = false,
+                isPublic = false
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
             )
             requestChatButton(
                 "\uD83D\uDDE3\uD83D\uDC6E",
                 requestIdChannelUserOwner,
                 isChannel = true,
-                isOwnedBy = true,
+                isOwnedBy = true
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
             )
         }
         row {
             requestGroupButton(
                 "👥",
-                requestIdGroup,
+                requestIdGroup
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
             )
             requestGroupButton(
                 "👥\uD83D\uDD17",
                 requestIdPublicGroup,
-                isPublic = true,
+                isPublic = true
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
             )
             requestGroupButton(
                 "👥❌\uD83D\uDD17",
                 requestIdPrivateGroup,
-                isPublic = false,
+                isPublic = false
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
             )
             requestGroupButton(
                 "👥\uD83D\uDC6E",
                 requestIdGroupUserOwner,
-                isOwnedBy = true,
+                isOwnedBy = true
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
             )
         }
         row {
             requestGroupButton(
                 "🏛",
                 requestIdForum,
-                isForum = true,
+                isForum = true
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
             )
             requestGroupButton(
                 "🏛\uD83D\uDD17",
                 requestIdPublicForum,
                 isPublic = true,
-                isForum = true,
+                isForum = true
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
             )
             requestGroupButton(
                 "🏛❌\uD83D\uDD17",
                 requestIdPrivateForum,
                 isPublic = false,
-                isForum = true,
+                isForum = true
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
             )
             requestGroupButton(
                 "🏛\uD83D\uDC6E",
                 requestIdForumUserOwner,
                 isOwnedBy = true,
-                isForum = true,
+                isForum = true
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
             )
         }
     }
@@ -287,7 +206,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,19 +11,12 @@ 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()
@@ -34,15 +27,12 @@ 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
             }
         }
 
@@ -51,12 +41,15 @@ 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

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

WebApp/src/jsMain/kotlin/main.kt

@@ -1,36 +1,22 @@
-import androidx.compose.runtime.*
+import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
-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
@@ -40,39 +26,19 @@ 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("/")
 
-    renderComposable("root") {
+    window.onload = {
-        Style(RootStyleSheet)
+        val scope = CoroutineScope(Dispatchers.Default)
-        DisposableEffect(null) {
+        runCatching {
-            scopeElement.classList.add(RootStyleSheet.rootClass)
 
-            onDispose {
+            scope.launchSafelyWithoutExceptions {
-                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(
+                        Json { }.encodeToString(
                             WebAppDataWrapper.serializer(),
                             WebAppDataWrapper(webApp.initData, webApp.initDataUnsafe.hash)
                         )
@@ -80,125 +46,42 @@ fun main() {
                 }
                 val dataIsSafe = response.bodyAsText().toBoolean()
 
+                document.body ?.log(
                     if (dataIsSafe) {
-                isSafeState.value = true
+                        "Data is safe"
-                logsState.add("Data is safe")
                     } else {
-                isSafeState.value = false
+                        "Data is unsafe"
-                logsState.add("Data is unsafe")
                     }
+                )
 
-            logsState.add(
+                document.body ?.log(
                     webApp.initDataUnsafe.chat.toString()
                 )
             }
 
-        Text(
+            document.body ?.appendElement("button") {
-            when (isSafeState.value) {
+                addEventListener("click", {
-                null -> "Checking safe state..."
+                    scope.launchSafelyWithoutExceptions {
-                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))
-                            logsState.add(url.build().toString())
+                                document.body ?.log(url.build().toString())
                             }.coroutineContext.job.join()
                         }
                     }
-            }
+                })
-        }) {
+                appendText("Answer in chat button")
-            Text("Answer in chat button")
+            } ?: window.alert("Unable to load body")
-        }
 
-        H3 { Text("Hide keyboard") }
+            document.body ?.appendElement("p", {})
-        val hideCountdown = remember { mutableStateOf<Int?>(null) }
+            document.body ?.appendText("Allow to write in private messages: ${webApp.initDataUnsafe.user ?.allowsWriteToPM ?: "User unavailable"}")
-        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()
+            document.body ?.appendElement("p", {})
-        H3 { Text("User info") }
+            document.body ?.appendText("Alerts:")
-        Text("Allow to write in private messages: ${webApp.initDataUnsafe.user ?.allowsWriteToPM ?: "User unavailable"}")
 
-        P()
+            document.body ?.appendElement("button") {
-        H3 { Text("Alerts") }
+                addEventListener("click", {
-        Button({
-            onClick {
                     webApp.showPopup(
                         PopupParams(
                             "It is sample title of default button",
@@ -208,7 +91,7 @@ fun main() {
                             DestructivePopupButton("destructive", "Destructive button")
                         )
                     ) {
-                    logsState.add(
+                        document.body ?.log(
                             when (it) {
                                 "default" -> "You have clicked default button in popup"
                                 "ok" -> "You have clicked ok button in popup"
@@ -217,176 +100,176 @@ fun main() {
                             }
                         )
                     }
-            }
+                })
-        }) {
+                appendText("Popup")
-            Text("Popup")
+            } ?: window.alert("Unable to load body")
-        }
+
-        Button({
+            document.body ?.appendElement("button") {
-            onClick {
+                addEventListener("click", {
                     webApp.showAlert(
                         "This is alert message"
                     ) {
-                    logsState.add(
+                        document.body ?.log(
                             "You have closed alert"
                         )
                     }
-            }
+                })
-        }) {
+                appendText("Alert")
-            Text("Alert")
+            } ?: window.alert("Unable to load body")
-        }
+
-        Button({
+            document.body ?.appendElement("p", {})
-            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"
                     ) {
-                    logsState.add(
+                        document.body ?.log(
                             "You have pressed \"${if (it) "Ok" else "Cancel"}\" in confirm"
                         )
                     }
-            }
+                })
-        }) {
+                appendText("Confirm")
-            Text("Confirm")
+            } ?: window.alert("Unable to load body")
-        }
 
-        P()
+            document.body ?.appendElement("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")
-        }
 
-        P()
+            document.body ?.appendElement("button") {
-        H3 { Text("Request contact") }
+                fun updateText() {
-        Button({
+                    textContent = if (webApp.isClosingConfirmationEnabled) {
-            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")
 
-        P()
+            document.body ?.appendElement("p", {})
-        H3 { Text("Colors") }
+
-        val headerColor = remember { mutableStateOf<Color.Hex>(Color.Hex("#000000")) }
+            document.body ?.appendElement("button") {
                 fun updateHeaderColor() {
                     val (r, g, b) = Random.nextUBytes(3)
-            headerColor.value = Color.Hex(r, g, b)
+                    val hex = Color.Hex(r, g, b)
-            webApp.setHeaderColor(headerColor.value)
+                    webApp.setHeaderColor(hex)
+                    (this as? HTMLButtonElement) ?.style ?.backgroundColor = hex.value
+                    textContent = "Header color: ${hex.value.uppercase()} (click to change)"
                 }
-        DisposableEffect(0) {
+                addEventListener("click", {
                     updateHeaderColor()
-            onDispose {  }
+                })
-        }
-        Button({
-            style {
-                backgroundColor(ComposeColor(headerColor.value.value))
-            }
-            onClick {
                 updateHeaderColor()
+            } ?: 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 {
-            key(headerColor.value) {
+                                            webApp.cloudStorage.remove(k.key) {
-                Text("Header color: ${webApp.headerColor ?.uppercase()} (click to change)")
+                                                it.onSuccess {
+                                                    webApp.cloudStorage.set(kInput.value, vInput.value) {
+                                                        document.body ?.log(it.toString())
+                                                        this@updateCloudStorageContent.updateCloudStorageContent()
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    })
+                                    this.textContent = "Save"
                                 }
                             }
 
-        P()
+                            appendElement("p", {})
-        val backgroundColor = remember { mutableStateOf<Color.Hex>(Color.Hex("#000000")) }
-        fun updateBackgroundColor() {
-            val (r, g, b) = Random.nextUBytes(3)
-            backgroundColor.value = Color.Hex(r, g, b)
-            webApp.setBackgroundColor(backgroundColor.value)
                         }
-        DisposableEffect(0) {
+                        appendElement("label") { textContent = "Cloud storage: add new" }
-            updateBackgroundColor()
+
-            onDispose {  }
+                        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()
                                     }
-        Button({
+                                })
-            style {
-                backgroundColor(ComposeColor(backgroundColor.value.value))
-            }
-            onClick {
-                updateBackgroundColor()
-            }
-        }) {
-            key(backgroundColor.value) {
-                Text("Background color: ${webApp.backgroundColor ?.uppercase()} (click to change)")
                             }
                         }
 
-        P()
+                        appendElement("p", {})
-        val bottomBarColor = remember { mutableStateOf<Color.Hex>(Color.Hex("#000000")) }
+                    }.onFailure {
-        fun updateBottomBarColor() {
+                        document.body ?.log(it.stackTraceToString())
-            val (r, g, b) = Random.nextUBytes(3)
-            bottomBarColor.value = Color.Hex(r, g, b)
-            webApp.setBottomBarColor(bottomBarColor.value)
-        }
-        DisposableEffect(0) {
-            updateBottomBarColor()
-            onDispose {  }
-        }
-        Button({
-            style {
-                backgroundColor(ComposeColor(bottomBarColor.value.value))
-            }
-            onClick {
-                updateBottomBarColor()
-            }
-        }) {
-            key(bottomBarColor.value) {
-                Text("Bottom bar color: ${webApp.bottomBarColor ?.uppercase()} (click to change)")
                     }
                 }
+            }
+            val cloudStorageContentDiv = document.body ?.appendElement("div") {} as HTMLDivElement
+
+            document.body ?.appendElement("p", {})
 
-        remember {
             webApp.apply {
-
                 onThemeChanged {
-                    logsState.add("Theme changed: ${webApp.themeParams}")
+                    document.body ?.log("Theme changed: ${webApp.themeParams}")
                 }
                 onViewportChanged {
-                    logsState.add("Viewport changed: ${it}")
+                    document.body ?.log("Viewport changed: ${it.isStateStable}")
                 }
                 backButton.apply {
                     onClick {
-                        logsState.add("Back button clicked")
+                        document.body ?.log("Back button clicked")
                         hapticFeedback.impactOccurred(
                             HapticFeedbackStyle.Heavy
                         )
@@ -396,425 +279,30 @@ fun main() {
                 mainButton.apply {
                     setText("Main button")
                     onClick {
-                        logsState.add("Main button clicked")
+                        document.body ?.log("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")
+                    document.body ?.log("Settings button clicked")
                 }
                 onWriteAccessRequested {
-                    logsState.add("Write access request result: $it")
+                    document.body ?.log("Write access request result: $it")
                 }
                 onContactRequested {
-                    logsState.add("Contact request result: $it")
+                    document.body ?.log("Contact request result: $it")
                 }
             }
-        }
+            webApp.ready()
-
+            document.body ?.appendElement("input", {
-        P()
+                (this as HTMLInputElement).value = window.location.href
-        let {
+            })
-            H3 { Text("Accelerometer") }
+            cloudStorageContentDiv.updateCloudStorageContent()
-            val enabledState = remember { mutableStateOf(webApp.accelerometer.isStarted) }
+        }.onFailure {
-            webApp.onAccelerometerStarted { enabledState.value = true }
+            window.alert(it.stackTraceToString())
-            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,7 +10,6 @@
         <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,43 +1,44 @@
-import dev.inmo.kslog.common.*
+import dev.inmo.kslog.common.KSLog
-import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
+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.micro_utils.ktor.server.createKtorServer
+import dev.inmo.tgbotapi.extensions.api.answers.answer
 import dev.inmo.tgbotapi.extensions.api.answers.answerInlineQuery
 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.*
-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.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onBaseInlineQuery
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
+import dev.inmo.tgbotapi.extensions.utils.formatting.makeTelegramStartattach
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onUnhandledCommand
+import dev.inmo.tgbotapi.extensions.utils.types.buttons.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onWriteAccessAllowed
-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.*
+import dev.inmo.tgbotapi.types.BotCommand
 import dev.inmo.tgbotapi.types.InlineQueries.InlineQueryResult.InlineQueryResultArticle
 import dev.inmo.tgbotapi.types.InlineQueries.InputMessageContent.InputTextMessageContent
+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.*
-import io.ktor.server.application.*
+import io.ktor.server.application.call
 import io.ktor.server.http.content.*
-import io.ktor.server.request.*
+import io.ktor.server.request.receiveText
-import io.ktor.server.response.*
+import io.ktor.server.response.respond
-import io.ktor.server.routing.*
+import io.ktor.server.routing.post
+import io.ktor.server.routing.routing
+import kotlinx.coroutines.Dispatchers
 import kotlinx.serialization.json.Json
 import java.io.File
+import java.nio.charset.Charset
 
 /**
  * Accepts two parameters:
  *
  * * Telegram Token
  * * URL where will be placed
- * * Port (default 8080)
  *
  * Will start the server to share the static (index.html and WebApp.js) on 0.0.0.0:8080
  */
@@ -56,79 +57,46 @@ suspend fun main(vararg args: String) {
             }
         )
     }
-    val initiationLogger = KSLog("Initialization")
 
     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/")
-            val prodSubFolder = File(baseJsFolder, "productionExecutable")
+            baseJsFolder.list() ?.forEach {
-            val devSubFolder = File(baseJsFolder, "developmentExecutable")
+                if (it == "productionExecutable" || it == "developmentExecutable") {
-
+                    staticFiles("", File(baseJsFolder, it)) {
-            val staticFolder = when {
+                        default("WebApp/build/dist/js/$it/index.html")
-                prodSubFolder.exists() -> {
-                    initiationLogger.i("Folder for static is ${prodSubFolder.absolutePath}")
-                    prodSubFolder
                     }
-                devSubFolder.exists() -> {
-                    initiationLogger.i("Folder for static is ${devSubFolder.absolutePath}")
-                    devSubFolder
                 }
-                else -> error("""
-                    Unable to detect any folder with static. Current working directory: ${File("").absolutePath}.
-                    Searched paths:
-                    * ${prodSubFolder.absolutePath}
-                    * ${devSubFolder.absolutePath}
-                """.trimIndent())
-            }
-
-            staticFiles("", staticFolder) {
-                default("${staticFolder.absolutePath}${File.separator}index.html")
             }
             post("inline") {
                 val requestBody = call.receiveText()
-                val queryId = call.parameters[webAppQueryIdField] ?.let(::InlineQueryId) ?: error("$webAppQueryIdField should be presented")
+                val queryId = call.parameters[webAppQueryIdField] ?: error("$webAppQueryIdField should be presented")
 
-                bot.answerInlineQuery(queryId, listOf(InlineQueryResultArticle(queryId, "Result", InputTextMessageContent(requestBody))))
+                bot.answer(queryId, InlineQueryResultArticle(queryId, "Result", InputTextMessageContent(requestBody)))
                 call.respond(HttpStatusCode.OK)
             }
             post("check") {
                 val requestBody = call.receiveText()
-                val webAppCheckData = Json.decodeFromString(WebAppDataWrapper.serializer(), requestBody)
+                val webAppCheckData = Json {  }.decodeFromString(WebAppDataWrapper.serializer(), requestBody)
 
                 val isSafe = telegramBotAPIUrlsKeeper.checkWebAppData(webAppCheckData.data, webAppCheckData.hash)
 
                 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)
 
     bot.buildBehaviourWithLongPolling(
         defaultExceptionsHandler = { it.printStackTrace() }
     ) {
+        val me = getMe()
         onCommand("reply_markup") {
             reply(
                 it,
@@ -196,7 +164,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())

WebHooks/README.md

@@ -1,28 +0,0 @@
-# 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

@@ -1,23 +0,0 @@
-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

@@ -1,87 +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.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,12 +26,6 @@ allprojects {
             }
         }
 
-        maven { url "https://proxy.nexus.inmo.dev/repository/maven-releases/" }
+        maven { url "https://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

@@ -1,13 +1,11 @@
 kotlin.code.style=official
 org.gradle.parallel=true
 # Due to parallel compilation project require next amount of memory on full build
-org.gradle.jvmargs=-Xmx3148m
+org.gradle.jvmargs=-Xmx2344m
-kotlin.daemon.jvmargs=-Xmx3g -Xms500m
 
 
-kotlin_version=2.2.10
+kotlin_version=1.9.22
-telegram_bot_api_version=29.0.0
+telegram_bot_api_version=10.1.0
-micro_utils_version=0.26.3
+micro_utils_version=0.20.37
-serialization_version=1.9.0
+serialization_version=1.6.2
-ktor_version=3.2.3
+ktor_version=2.3.8
-compose_version=1.8.2

gradle/wrapper/gradle-wrapper.properties

@@ -1,7 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.1-bin.zip
-networkTimeout=10000
-validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip

gradlew

@@ -1,128 +1,78 @@
-#!/bin/sh
+#!/usr/bin/env sh
-
-#
-# Copyright © 2015 the original authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# SPDX-License-Identifier: Apache-2.0
-#
 
 ##############################################################################
-#
+##
-#   Gradle start up script for POSIX generated by Gradle.
+##  Gradle start up script for UN*X
-#
+##
-#   Important for running:
-#
-#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
-#       noncompliant, but you have some other compliant shell such as ksh or
-#       bash, then to run this script, type that shell name before the whole
-#       command line, like:
-#
-#           ksh Gradle
-#
-#       Busybox and similar reduced shells will NOT work, because this script
-#       requires all of these POSIX shell features:
-#         * functions;
-#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «command», «set», and «ulimit».
-#
-#   Important for patching:
-#
-#   (2) This script targets any POSIX shell, so it avoids extensions provided
-#       by Bash, Ksh, etc; in particular arrays are avoided.
-#
-#       The "traditional" practice of packing multiple parameters into a
-#       space-separated string is a well documented source of bugs and security
-#       problems, so this is (mostly) avoided, by progressively accumulating
-#       options in "$@", and eventually passing that to Java.
-#
-#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
-#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
-#       see the in-line comments for details.
-#
-#       There are tweaks for specific operating systems such as AIX, CygWin,
-#       Darwin, MinGW, and NonStop.
-#
-#   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
-#       within the Gradle project.
-#
-#       You can find Gradle at https://github.com/gradle/gradle/.
-#
 ##############################################################################
 
 # Attempt to set APP_HOME
-
 # Resolve links: $0 may be a link
-app_path=$0
+PRG="$0"
-
+# Need this for relative symlinks.
-# Need this for daisy-chained symlinks.
+while [ -h "$PRG" ] ; do
-while
+    ls=`ls -ld "$PRG"`
-    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    link=`expr "$ls" : '.*-> \(.*\)$'`
-    [ -h "$app_path" ]
+    if expr "$link" : '/.*' > /dev/null; then
-do
+        PRG="$link"
-    ls=$( ls -ld "$app_path" )
+    else
-    link=${ls#*' -> '}
+        PRG=`dirname "$PRG"`"/$link"
-    case $link in             #(
+    fi
-      /*)   app_path=$link ;; #(
-      *)    app_path=$APP_HOME$link ;;
-    esac
 done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
 
-# This is normally unused
+APP_NAME="Gradle"
-# shellcheck disable=SC2034
+APP_BASE_NAME=`basename "$0"`
-APP_BASE_NAME=${0##*/}
+
-# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+DEFAULT_JVM_OPTS=""
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD=maximum
+MAX_FD="maximum"
 
 warn () {
     echo "$*"
-} >&2
+}
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-} >&2
+}
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "$( uname )" in                #(
+case "`uname`" in
-  CYGWIN* )         cygwin=true  ;; #(
+  CYGWIN* )
-  Darwin* )         darwin=true  ;; #(
+    cygwin=true
-  MSYS* | MINGW* )  msys=true    ;; #(
+    ;;
-  NONSTOP* )        nonstop=true ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
 esac
 
-
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD=$JAVA_HOME/jre/sh/java
+        JAVACMD="$JAVA_HOME/jre/sh/java"
     else
-        JAVACMD=$JAVA_HOME/bin/java
+        JAVACMD="$JAVA_HOME/bin/java"
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -131,118 +81,92 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD=java
+    JAVACMD="java"
-    if ! command -v java >/dev/null 2>&1
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-    then
-        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
 fi
-fi
 
 # Increase the maximum file descriptors if we can.
-if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    case $MAX_FD in #(
+    MAX_FD_LIMIT=`ulimit -H -n`
-      max*)
+    if [ $? -eq 0 ] ; then
-        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-        # shellcheck disable=SC2039,SC3045
+            MAX_FD="$MAX_FD_LIMIT"
-        MAX_FD=$( ulimit -H -n ) ||
+        fi
-            warn "Could not query maximum file descriptor limit"
+        ulimit -n $MAX_FD
-    esac
+        if [ $? -ne 0 ] ; then
-    case $MAX_FD in  #(
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
-      '' | soft) :;; #(
+        fi
-      *)
+    else
-        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-        # shellcheck disable=SC2039,SC3045
+    fi
-        ulimit -n "$MAX_FD" ||
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
-    esac
 fi
 
-# Collect all arguments for the java command, stacking in reverse order:
+# For Darwin, add options to specify how the application appears in the dock
-#   * args from the command line
+if $darwin; then
-#   * the main class name
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-#   * -classpath
-#   * -D...appname settings
-#   * --module-path (only if needed)
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if "$cygwin" || "$msys" ; then
-    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-
-    JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    for arg do
-        if
-            case $arg in                                #(
-              -*)   false ;;                            # don't mess with options #(
-              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
-                    [ -e "$t" ] ;;                      #(
-              *)    false ;;
-            esac
-        then
-            arg=$( cygpath --path --ignore --mixed "$arg" )
 fi
-        # Roll the args list around exactly as many times as the number of
+
-        # args, so each arg winds up back in the position where it started, but
+# For Cygwin, switch paths to Windows format before running java
-        # possibly modified.
+if $cygwin ; then
-        #
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-        # NB: a `for` loop captures its iteration list before it begins, so
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-        # changing the positional parameters here affects neither the number of
+    JAVACMD=`cygpath --unix "$JAVACMD"`
-        # iterations, nor the values presented in `arg`.
+
-        shift                   # remove old arg
+    # We build the pattern for arguments to be converted via cygpath
-        set -- "$@" "$arg"      # push replacement arg
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
     done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
 fi
 
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+# Collect all arguments for the java command, following the shell quoting and substitution rules
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
 
-# Collect all arguments for the java command:
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-#     and any embedded shellness will be escaped.
+  cd "$(dirname "$0")"
-#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
-#     treated as '${Hostname}' itself on the command line.
-
-set -- \
-        "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
-        "$@"
-
-# Stop when "xargs" is not available.
-if ! command -v xargs >/dev/null 2>&1
-then
-    die "xargs is not available"
 fi
 
-# Use "xargs" to parse quoted args.
-#
-# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
-#
-# In Bash we could simply go:
-#
-#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
-#   set -- "${ARGS[@]}" "$@"
-#
-# but POSIX shell has neither arrays nor command substitution, so instead we
-# post-process each arg (as a line of input to sed) to backslash-escape any
-# character that might be a shell metacharacter, then use eval to reverse
-# that process (while maintaining the separation between arguments), and wrap
-# the whole thing up as a single "set" statement.
-#
-# This will of course break if any of these variables contains a newline or
-# an unmatched quote.
-#
-
-eval "set -- $(
-        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
-        xargs -n1 |
-        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
-        tr '\n' ' '
-    )" '"$@"'
-
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -1,21 +1,3 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-@rem SPDX-License-Identifier: Apache-2.0
-@rem
-
 @if "%DEBUG%" == "" @echo off
 @rem ##########################################################################
 @rem
@@ -28,28 +10,24 @@ if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
 if "%DIRNAME%" == "" set DIRNAME=.
-@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+set DEFAULT_JVM_OPTS=
 
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if %ERRORLEVEL% equ 0 goto execute
+if "%ERRORLEVEL%" == "0" goto init
 
-echo. 1>&2
+echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo. 1>&2
+echo.
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation. 1>&2
+echo location of your Java installation.
 
 goto fail
 
@@ -57,35 +35,48 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto execute
+if exist "%JAVA_EXE%" goto init
 
-echo. 1>&2
+echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo. 1>&2
+echo.
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation. 1>&2
+echo location of your Java installation.
 
 goto fail
 
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
 :execute
 @rem Setup the command line
 
-
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
 
 :end
 @rem End local scope for the variables with windows NT shell
-if %ERRORLEVEL% equ 0 goto mainEnd
+if "%ERRORLEVEL%"=="0" goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-set EXIT_CODE=%ERRORLEVEL%
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-if %EXIT_CODE% equ 0 set EXIT_CODE=1
+exit /b 1
-if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
-exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal

settings.gradle

@@ -47,19 +47,3 @@ include ":ReactionsInfoBot"
 include ":LinkPreviewsBot"
 
 include ":BoostsInfoBot"
-
-include ":BusinessConnectionsBot"
-
-include ":StarTransactionsBot"
-
-include ":GiveawaysBot"
-
-include ":CustomBot"
-
-include ":MemberUpdatedWatcherBot"
-
-include ":WebHooks"
-
-include ":SuggestedPosts"
-
-include ":ChecklistsBot"