add copyText sample button

19.0.0

.github/workflows/build.yml

@@ -10,10 +10,11 @@ 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
+        run: ./gradlew build --no-daemon

.gitignore

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

.template/bot/.env

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

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

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

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

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

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

@@ -0,0 +1,208 @@
+#!/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.*
+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.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.*
-import dev.inmo.tgbotapi.types.chat.member.ChatCommonAdministratorRights
+import dev.inmo.tgbotapi.extensions.utils.types.buttons.flatReplyKeyboard
+import dev.inmo.tgbotapi.extensions.utils.types.buttons.requestChannelButton
 import dev.inmo.tgbotapi.types.request.RequestId
 import dev.inmo.tgbotapi.utils.regular
 import korlibs.time.DateFormat
@@ -52,12 +52,19 @@ suspend fun main(args: Array<String>) {
         }
 
         onChatShared(initialFilter = { it.chatEvent.requestId == requestChatId }) {
-            val boosts = getUserChatBoosts(it.chatEvent.chatId, it.chat.id)
-            reply(
-                it
-            ) {
-                boosts.boosts.forEach {
-                    regular("Boost added: ${DateFormat.FORMAT1.format(it.addDate.asDate)}; Boost expire: ${DateFormat.FORMAT1.format(it.expirationDate.asDate)}; Unformatted: $it") + "\n"
+            val boostsInfoContrainer = runCatching {
+                getUserChatBoosts(it.chatEvent.chatId, it.chat.id)
+            }.getOrNull()
+
+            reply(it) {
+                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"
+                        }
+                    }
                 }
             }
         }

BusinessConnectionsBot/README.md

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

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

@@ -0,0 +1,102 @@
+import dev.inmo.kslog.common.KSLog
+import dev.inmo.kslog.common.LogLevel
+import dev.inmo.kslog.common.defaultMessageFormatter
+import dev.inmo.kslog.common.setDefaultKSLog
+import dev.inmo.tgbotapi.extensions.api.bot.getMe
+import dev.inmo.tgbotapi.extensions.api.chat.modify.pinChatMessage
+import dev.inmo.tgbotapi.extensions.api.chat.modify.unpinChatMessage
+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.behaviour_builder.telegramBotWithBehaviourAndLongPolling
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
+import dev.inmo.tgbotapi.extensions.utils.accessibleMessageOrNull
+import dev.inmo.tgbotapi.extensions.utils.ifAccessibleMessage
+import dev.inmo.tgbotapi.extensions.utils.ifBusinessContentMessage
+import dev.inmo.tgbotapi.extensions.utils.textContentOrNull
+import dev.inmo.tgbotapi.types.ChatId
+import dev.inmo.tgbotapi.types.business_connection.BusinessConnectionId
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+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 businessConnectionsChatsMutex = Mutex()
+
+    telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO)) {
+        val me = getMe()
+        println(me)
+
+        onBusinessConnectionEnabled {
+            businessConnectionsChatsMutex.withLock {
+                businessConnectionsChats[it.id] = it.userChatId
+            }
+            send(it.userChatId, "Business connection ${it.businessConnectionId.string} has been enabled")
+        }
+        onBusinessConnectionDisabled {
+            businessConnectionsChatsMutex.withLock {
+                businessConnectionsChats.remove(it.id)
+            }
+            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(sent, "User have sent this message to you in the ${businessContentMessage.businessConnectionId.string} related chat")
+                }
+            }
+        }
+        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}")
+        }
+    }.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.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 
 suspend fun main(args: Array<String>) {
     val bot = telegramBot(args.first())

CustomBot/README.md

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

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

@@ -0,0 +1,51 @@
+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" }
+    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
+                    }
+                }
+            }
+        }
+    ) {
+        // start here!!
+        val me = getMe()
+        println(me)
+
+        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.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
+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,20 +1,20 @@
-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.api.send.sendMessage
-import dev.inmo.tgbotapi.extensions.behaviour_builder.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
-import dev.inmo.tgbotapi.extensions.utils.extensions.parseCommandsWithParams
+import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitAnyContentMessage
+import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndFSMAndStartLongPolling
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.command
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
+import dev.inmo.tgbotapi.extensions.utils.extensions.parseCommandsWithArgs
 import dev.inmo.tgbotapi.extensions.utils.extensions.sameThread
-import dev.inmo.tgbotapi.extensions.utils.formatting.*
+import dev.inmo.tgbotapi.extensions.utils.textContentOrNull
+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.extensions.threadIdOrNull
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.first
 
@@ -54,7 +54,8 @@ suspend fun main(args: Array<String>) {
             val content = contentMessage.content
 
             when {
-                content is TextContent && content.parseCommandsWithParams().keys.contains("stop") -> StopState(it.context)
+                content is TextContent && content.text == "/stop"
+                || content is TextContent && content.parseCommandsWithArgs().keys.contains("stop") -> StopState(it.context)
                 else -> {
                     execute(content.createResend(it.context))
                     it
@@ -72,5 +73,17 @@ 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,38 +2,17 @@ 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.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.api.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.onContentMessage
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onMedia
 import dev.inmo.tgbotapi.requests.abstracts.asMultipartFile
-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.actions.*
 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.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.types.message.content.*
 import dev.inmo.tgbotapi.utils.filenameFromUrl
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -55,13 +34,27 @@ suspend fun main(args: Array<String>) {
             val content = it.content
             val pathedFile = bot.getFileAdditionalInfo(content.media)
             val outFile = File(directoryOrFile, pathedFile.filePath.filenameFromUrl)
-            runCatching {
-                bot.downloadFile(content.media, outFile)
-            }.onFailure {
-                it.printStackTrace()
+            withTypingAction(it.chat.id) {
+                runCatching {
+                    bot.downloadFile(content.media, outFile)
+                }.onFailure {
+                    it.printStackTrace()
+                }.onSuccess { _ ->
+                    reply(it, "Saved to ${outFile.absolutePath}")
+                }
             }.onSuccess { _ ->
-                reply(it, "Saved to ${outFile.absolutePath}")
-                withAction(it.chat.id, TypingAction) {
+                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,15 +1,13 @@
 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 most easiest bot - it will just print information about itself
+ * This is one of the easiest bots - it will just print information about itself
  */
 suspend fun main(vararg args: String) {
     val botToken = args.first()

GiveawaysBot/README.md

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

GiveawaysBot/build.gradle

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

@@ -0,0 +1,57 @@
+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,23 +1,21 @@
 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.*
+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.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.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 
 /**
  * The main purpose of this bot is just to answer "Oh, hi, " and add user mention here
@@ -28,24 +26,35 @@ suspend fun main(vararg args: String) {
 
     telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO)) {
         val me = getMe()
-        onMentionWithAnyContent(me) { message ->
-            val chat = message.chat
-
+        onContentMessage(
+            initialFilter = initialFilter@{ it.text ?.contains(me.username ?.full ?: return@initialFilter false) == true }
+        ) { message ->
             val answerText = when (val chat = message.chat) {
                 is PreviewChannelChat -> {
-                    val answer = "Hi everybody in this channel \"${chat.title}\""
-                    reply(message, answer, MarkdownV2)
-                    return@onMentionWithAnyContent
+                    val sender = message.sender_chat
+                    val answer = "Hi everybody in this channel \"${chat.title}\"" + if (sender != null) {
+                        " and you, " + when (sender) {
+                            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@onMentionWithAnyContent
+                    return@onContentMessage
                 }
                 is PreviewGroupChat -> {
-                    message.ifFromChannelGroupContentMessage {
+                    message.ifFromChannelGroupContentMessage<Unit> {
                         val answer = "Hi, ${it.senderChat.title}"
                         reply(message, answer, MarkdownV2)
-                        return@onMentionWithAnyContent
+                        return@onContentMessage
                     }
                     "Oh, hi, " + when (chat) {
                         is SupergroupChat -> (chat.username ?.username ?: getChat(chat).inviteLink) ?.let {
@@ -56,6 +65,10 @@ 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

@@ -33,6 +33,6 @@ kotlin {
 }
 
 dependencies {
-    implementation 'io.ktor:ktor-client-logging-jvm:2.3.7'
+    implementation 'io.ktor:ktor-client-logging-jvm:2.3.12'
 }
 

InlineQueriesBot/src/commonMain/kotlin/Bot.kt

@@ -9,6 +9,7 @@ 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
 
@@ -31,9 +32,9 @@ suspend fun doInlineQueriesBot(token: String) {
             answer(
                 it,
                 results = results.map { resultNumber ->
-                    val resultAsString = resultNumber.toString()
+                    val inlineQueryId = InlineQueryId(resultNumber.toString())
                     InlineQueryResultArticle(
-                        resultAsString,
+                        inlineQueryId,
                         "Title $resultNumber",
                         InputTextMessageContent(
                             buildEntities {

InlineQueriesBot/src/jvmMain/kotlin/InlineQueriesBot.kt

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

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

@@ -1,26 +1,27 @@
 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.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.*
+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.*
 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.*
-import kotlinx.coroutines.*
-
-private const val nextPageData = "next"
-private const val previousPageData = "previous"
+import dev.inmo.tgbotapi.utils.PreviewFeature
+import dev.inmo.tgbotapi.utils.botCommand
+import dev.inmo.tgbotapi.utils.regular
+import dev.inmo.tgbotapi.utils.row
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.currentCoroutineContext
 
 fun String.parsePageAndCount(): Pair<Int, Int>? {
     val (pageString, countString) = split(" ").takeIf { it.count() > 1 } ?: return null
@@ -44,6 +45,9 @@ fun InlineKeyboardBuilder.includePageButtons(page: Int, count: Int) {
             }
         }
     }
+    row {
+        copyTextButton("Command copy button", "/inline $page $count")
+    }
 
     row {
         if (page - 1 > 2) {
@@ -72,6 +76,7 @@ fun InlineKeyboardBuilder.includePageButtons(page: Int, count: Int) {
     }
 }
 
+@OptIn(PreviewFeature::class)
 suspend fun activateKeyboardsBot(
     token: String,
     print: (Any) -> Unit
@@ -82,11 +87,13 @@ suspend fun activateKeyboardsBot(
 
     bot.buildBehaviourWithLongPolling(CoroutineScope(currentCoroutineContext() + SupervisorJob())) {
         onCommandWithArgs("inline") { message, args ->
-            val numberOfPages = args.firstOrNull() ?.toIntOrNull() ?: 10
+            val numberArgs = args.mapNotNull { it.toIntOrNull() }
+            val numberOfPages = numberArgs.getOrNull(1) ?: numberArgs.firstOrNull() ?: 10
+            val page = numberArgs.firstOrNull() ?.takeIf { numberArgs.size > 1 } ?.coerceAtLeast(1) ?: 1
             reply(
                 message,
                 replyMarkup = inlineKeyboard {
-                    includePageButtons(1, numberOfPages)
+                    includePageButtons(page, numberOfPages)
                 }
             ) {
                 regular("Your inline keyboard with $numberOfPages pages")
@@ -137,7 +144,7 @@ suspend fun activateKeyboardsBot(
                 it,
                 results = listOf(
                     InlineQueryResultArticle(
-                        it.query,
+                        InlineQueryId(it.query),
                         "Send buttons",
                         InputTextMessageContent("It is sent via inline mode inline buttons"),
                         replyMarkup = inlineKeyboard {

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

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

LinkPreviewsBot/src/main/kotlin/LinkPreviewsBot.kt

@@ -3,24 +3,15 @@ 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
 
 /**
@@ -41,17 +32,17 @@ suspend fun main(vararg args: String) {
     val bot = telegramBot(botToken)
 
     bot.buildBehaviourWithLongPolling {
-        onContentMessage {
-            val url = it.withContentOrNull<TextedContent>() ?.let {
-                it.content.textSources.firstNotNullOfOrNull {
+        onContentMessage { contentMessage ->
+            val url = contentMessage.withContentOrNull<TextedContent>() ?.let { message ->
+                message.content.textSources.firstNotNullOfOrNull {
                     it.textLinkTextSourceOrNull() ?.url ?: it.uRLTextSourceOrNull() ?.source
                 }
             } ?: null.apply {
-                reply(it) {
+                reply(contentMessage) {
                     regular("I am support only content with text contains url only")
                 }
             } ?: return@onContentMessage
-            it.withContentOrNull<TextedContent>() ?.let {
+            contentMessage.withContentOrNull<TextedContent>() ?.let {
                 send(
                     it.chat,
                     it.content.textSources,

LiveLocationsBot/src/main/kotlin/LiveLocationsBot.kt

@@ -1,33 +1,15 @@
 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
@@ -64,7 +46,7 @@ suspend fun main(vararg args: String) {
                 handleLiveLocation(
                     it.chat.id,
                     locationsFlow,
-                    sentMessageFlow = FlowCollector { currentMessageState.emit(it) }
+                    sentMessageFlow = { currentMessageState.emit(it) },
                 )
             }
 

MemberUpdatedWatcherBot/README.md

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

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

@@ -0,0 +1,98 @@
+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,58 +1,78 @@
-import com.benasher44.uuid.uuid4
+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.chat.get.getChat
-import dev.inmo.tgbotapi.extensions.api.send.*
+import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
+import dev.inmo.tgbotapi.extensions.api.send.polls.sendQuizPoll
 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.*
-import dev.inmo.tgbotapi.extensions.utils.extensions.raw.sender_chat
-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.ChatId
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onPollAnswer
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onPollUpdates
+import dev.inmo.tgbotapi.extensions.utils.customEmojiTextSourceOrNull
+import dev.inmo.tgbotapi.extensions.utils.extensions.parseCommandsWithArgsSources
+import dev.inmo.tgbotapi.types.BotCommand
 import dev.inmo.tgbotapi.types.IdChatIdentifier
-import dev.inmo.tgbotapi.types.PollIdentifier
+import dev.inmo.tgbotapi.types.PollId
 import dev.inmo.tgbotapi.types.ReplyParameters
-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.InputPollOption
 import dev.inmo.tgbotapi.types.polls.PollAnswer
-import dev.inmo.tgbotapi.types.polls.PollOption
-import dev.inmo.tgbotapi.types.polls.RegularPoll
-import dev.inmo.tgbotapi.utils.PreviewFeature
-import dev.inmo.tgbotapi.utils.extensions.escapeMarkdownV2Common
-import kotlinx.coroutines.*
+import dev.inmo.tgbotapi.utils.buildEntities
+import dev.inmo.tgbotapi.utils.customEmoji
+import dev.inmo.tgbotapi.utils.regular
+import dev.inmo.tgbotapi.utils.underline
+import kotlinx.coroutines.CoroutineScope
+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
- * updates of any of it.
+ * any update.
  * 
  * * 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 me = getMe()
-
-        val pollToChat = mutableMapOf<PollIdentifier, IdChatIdentifier>()
+        val pollToChat = mutableMapOf<PollId, IdChatIdentifier>()
         val pollToChatMutex = Mutex()
 
-        onCommand("anonymous") {
+        onCommand("anonymous", requireOnlyCommandInMessage = false) {
+            val customEmoji = it.content.parseCommandsWithArgsSources()
+                .toList()
+                .firstOrNull { it.first.command == "anonymous" }
+                ?.second
+                ?.firstNotNullOfOrNull { it.customEmojiTextSourceOrNull() }
             val sentPoll = sendRegularPoll(
-                it.chat,
-                "Test regular anonymous poll",
+                it.chat.id,
+                buildEntities {
+                    regular("Test regular anonymous poll")
+                    if (customEmoji != null) {
+                        customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
+                    }
+                },
                 (1 .. 10).map {
-                    it.toString()
+                    InputPollOption {
+                        regular(it.toString()) + " "
+                        if (customEmoji != null) {
+                            customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
+                        }
+                    }
                 },
                 isAnonymous = true,
                 replyParameters = ReplyParameters(it)
@@ -62,12 +82,27 @@ suspend fun main(vararg args: String) {
             }
         }
 
-        onCommand("public") {
+        onCommand("public", requireOnlyCommandInMessage = false) {
+            val customEmoji = it.content.parseCommandsWithArgsSources()
+                .toList()
+                .firstOrNull { it.first.command == "public" }
+                ?.second
+                ?.firstNotNullOfOrNull { it.customEmojiTextSourceOrNull() }
             val sentPoll = sendRegularPoll(
-                it.chat,
-                "Test regular anonymous poll",
+                it.chat.id,
+                buildEntities {
+                    regular("Test regular non anonymous poll")
+                    if (customEmoji != null) {
+                        customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
+                    }
+                },
                 (1 .. 10).map {
-                    it.toString()
+                    InputPollOption {
+                        regular(it.toString()) + " "
+                        if (customEmoji != null) {
+                            customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
+                        }
+                    }
                 },
                 isAnonymous = false,
                 replyParameters = ReplyParameters(it)
@@ -77,6 +112,44 @@ 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
 
@@ -95,6 +168,12 @@ 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()
 }

ReactionsInfoBot/src/main/kotlin/ReactionsInfoBot.kt

@@ -6,7 +6,6 @@ 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
@@ -49,6 +48,7 @@ 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,19 +1,19 @@
 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.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.api.send.withTypingAction
 import dev.inmo.tgbotapi.extensions.behaviour_builder.filters.MessageFilterByChat
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
-import dev.inmo.tgbotapi.extensions.utils.shortcuts.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
+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.types.quoteEntitiesField
 import dev.inmo.tgbotapi.utils.extensions.threadIdOrNull
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.currentCoroutineContext
 
 suspend fun activateResenderBot(
     token: String,
@@ -22,6 +22,7 @@ suspend fun activateResenderBot(
     telegramBotWithBehaviourAndLongPolling(token, scope = CoroutineScope(currentCoroutineContext() + SupervisorJob())) {
         onContentMessage(
             subcontextUpdatesFilter = MessageFilterByChat,
+            initialFilter = { it !is BusinessContentMessage<*> || !it.sentByBusinessConnectionOwner }
         ) {
             val chat = it.chat
 
@@ -37,7 +38,8 @@ suspend fun activateResenderBot(
                                 entities = quote ?.textSources ?: emptyList(),
                                 quotePosition = quote ?.position
                             )
-                        }
+                        },
+                        effectId = it.possiblyWithEffectMessageOrNull() ?.effectId
                     )
                 ) {
                     it.forEach(print)

RightsChangerBot/build.gradle

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

RightsChangerBot/src/main/kotlin/RightsChanger.kt

@@ -1,4 +1,9 @@
+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.firstOf
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.micro_utils.fsm.common.State
 import dev.inmo.tgbotapi.bot.ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
@@ -11,7 +16,9 @@ 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.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitChatSharedEventsMessages
+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.*
@@ -22,12 +29,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.*
+import dev.inmo.tgbotapi.types.chat.member.AdministratorChatMember
+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
@@ -47,12 +54,23 @@ sealed interface UserRetrievingStep : State {
     ) : UserRetrievingStep
 }
 
+@OptIn(PreviewFeature::class)
 suspend fun main(args: Array<String>) {
     val botToken = args.first()
 
+    val isDebug = args.getOrNull(2) == "debug"
+
+    if (isDebug) {
+        setDefaultKSLog(
+            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
+                println(defaultMessageFormatter(level, tag, message, throwable))
+            }
+        )
+    }
+
     val bot = telegramBot(botToken)
 
-    val allowedAdmin = ChatId(args[1].toLong())
+    val allowedAdmin = ChatId(RawChatId(args[1].toLong()))
 
     fun Boolean?.allowedSymbol() = when (this) {
         true -> "✅"
@@ -88,7 +106,7 @@ suspend fun main(args: Array<String>) {
 
     suspend fun BehaviourContext.getUserChatPermissions(chatId: ChatId, userId: UserId): ChatPermissions? {
         val chatMember = getChatMember(chatId, userId)
-        return chatMember.restrictedChatMemberOrNull() ?: chatMember.whenMemberChatMember {
+        return chatMember.restrictedMemberChatMemberOrNull() ?: chatMember.whenMemberChatMember {
             getChat(chatId).extendedGroupChatOrNull() ?.permissions
         }
     }
@@ -209,7 +227,6 @@ 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) {
@@ -362,11 +379,10 @@ suspend fun main(args: Array<String>) {
             initialFilter = { it.user.id == allowedAdmin }
         ) {
             val (channelIdString, userIdString) = it.data.split(" ").drop(1)
-            val channelId = ChatId(channelIdString.toLong())
-            val userId = ChatId(userIdString.toLong())
+            val channelId = ChatId(RawChatId(channelIdString.toLong()))
+            val userId = ChatId(RawChatId(userIdString.toLong()))
             val chatMember = getChatMember(channelId, userId)
             val asAdmin = chatMember.administratorChatMemberOrNull()
-            val asMember = chatMember.memberChatMemberOrNull()
 
             val realData = it.data.takeWhile { it != ' ' }
 
@@ -489,7 +505,6 @@ 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(
@@ -517,5 +532,9 @@ suspend fun main(args: Array<String>) {
             BotCommand("rights_in_channel", "Trigger granular keyboard. Use with reply to user"),
             scope = BotCommandScope.AllGroupChats
         )
+
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
+            println(it)
+        }
     }.join()
 }

StarTransactionsBot/README.md

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

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

@@ -0,0 +1,184 @@
+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,29 +1,25 @@
 import dev.inmo.micro_utils.coroutines.defaultSafelyWithoutExceptionHandler
 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.get.*
-import dev.inmo.tgbotapi.extensions.api.send.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
-import dev.inmo.tgbotapi.types.StickerFormat
+import dev.inmo.tgbotapi.extensions.api.bot.getMe
+import dev.inmo.tgbotapi.extensions.api.get.getCustomEmojiStickerOrNull
+import dev.inmo.tgbotapi.extensions.api.get.getStickerSet
+import dev.inmo.tgbotapi.extensions.api.get.getStickerSetOrNull
+import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.extensions.api.send.withTypingAction
+import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
+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.*
-import dev.inmo.tgbotapi.types.stickers.AnimatedStickerSet
-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.message.textsources.CustomEmojiTextSource
+import dev.inmo.tgbotapi.types.message.textsources.regular
+import dev.inmo.tgbotapi.types.message.textsources.separateForText
 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.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.currentCoroutineContext
 
 fun StickerSet?.buildInfo() = buildEntities {
     if (this@buildInfo == null) {
@@ -31,12 +27,6 @@ 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"
@@ -44,7 +34,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)
+        ) + " sticker set with title " + bold(title) + " and name " + bold(name.string)
     }
 }
 

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,11 +10,14 @@ 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.*
+import dev.inmo.tgbotapi.types.files.CustomEmojiSticker
+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
@@ -32,7 +35,7 @@ suspend fun main(args: Array<String>) {
         }
     ) {
         val me = getMe()
-        fun Chat.stickerSetName() = "s${id.chatId}_by_${me.username ?.usernameWithoutAt}"
+        fun Chat.stickerSetName() = StickerSetName("s${id.chatId}_by_${me.username ?.withoutAt}")
         onCommand("start") {
             reply(it) {
                 botCommand("delete") + " - to clear stickers"
@@ -55,16 +58,19 @@ 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()
                 )
@@ -73,18 +79,25 @@ suspend fun main(args: Array<String>) {
             runCatchingSafely {
                 getStickerSet(stickerSetName)
             }.onSuccess { stickerSet ->
-                addStickerToSet(it.chat.id.toChatId(), stickerSet.name, newSticker).also { _ ->
+                runCatching {
+                    addStickerToSet(it.chat.id.toChatId(), stickerSet.name, newSticker).also { _ ->
+                        reply(
+                            it,
+                            getStickerSet(stickerSetName).stickers.last()
+                        )
+                    }
+                }.onFailure { exception ->
+                    exception.printStackTrace()
                     reply(
                         it,
-                        getStickerSet(stickerSetName).stickers.last()
+                        "Unable to add sticker in stickerset"
                     )
                 }
-            }.onFailure { _ ->
+            }.onFailure { exception ->
                 createNewStickerSet(
                     it.chat.id.toChatId(),
-                    stickerSetName,
+                    stickerSetName.string,
                     "Sticker set by ${me.firstName}",
-                    it.content.media.stickerFormat,
                     listOf(
                         newSticker
                     ),
@@ -97,5 +110,9 @@ suspend fun main(args: Array<String>) {
                 }
             }
         }
+
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
+            println(it)
+        }
     }.second.join()
 }

TopicsHandling/src/main/kotlin/TopicsHandling.kt

@@ -1,18 +1,8 @@
 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.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.chat.forum.*
 import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand

UserChatShared/src/main/kotlin/UserChatShared.kt

@@ -1,12 +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.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.*
+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.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
@@ -18,6 +21,15 @@ 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)
 
@@ -55,35 +67,53 @@ 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 {
@@ -91,101 +121,152 @@ 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
             )
         }
     }

WebApp/src/jsMain/kotlin/main.kt

@@ -26,6 +26,7 @@ fun HTMLElement.log(text: String) {
     appendElement("p", {})
 }
 
+@OptIn(ExperimentalUnsignedTypes::class)
 fun main() {
     console.log("Web app started")
     val client = HttpClient()
@@ -38,7 +39,7 @@ fun main() {
             scope.launchSafelyWithoutExceptions {
                 val response = client.post("$baseUrl/check") {
                     setBody(
-                        Json { }.encodeToString(
+                        Json.encodeToString(
                             WebAppDataWrapper.serializer(),
                             WebAppDataWrapper(webApp.initData, webApp.initDataUnsafe.hash)
                         )
@@ -181,7 +182,7 @@ fun main() {
                     val hex = Color.Hex(r, g, b)
                     webApp.setHeaderColor(hex)
                     (this as? HTMLButtonElement) ?.style ?.backgroundColor = hex.value
-                    textContent = "Header color: ${hex.value.uppercase()} (click to change)"
+                    textContent = "Header color: ${webApp.headerColor ?.uppercase()} (click to change)"
                 }
                 addEventListener("click", {
                     updateHeaderColor()
@@ -191,6 +192,38 @@ fun main() {
 
             document.body ?.appendElement("p", {})
 
+            document.body ?.appendElement("button") {
+                fun updateBackgroundColor() {
+                    val (r, g, b) = Random.nextUBytes(3)
+                    val hex = Color.Hex(r, g, b)
+                    webApp.setBackgroundColor(hex)
+                    (this as? HTMLButtonElement) ?.style ?.backgroundColor = hex.value
+                    textContent = "Background color: ${webApp.backgroundColor ?.uppercase()} (click to change)"
+                }
+                addEventListener("click", {
+                    updateBackgroundColor()
+                })
+                updateBackgroundColor()
+            } ?: window.alert("Unable to load body")
+
+            document.body ?.appendElement("p", {})
+
+            document.body ?.appendElement("button") {
+                fun updateBottomBarColor() {
+                    val (r, g, b) = Random.nextUBytes(3)
+                    val hex = Color.Hex(r, g, b)
+                    webApp.setBottomBarColor(hex)
+                    (this as? HTMLButtonElement) ?.style ?.backgroundColor = hex.value
+                    textContent = "Bottom bar color: ${webApp.bottomBarColor ?.uppercase()} (click to change)"
+                }
+                addEventListener("click", {
+                    updateBottomBarColor()
+                })
+                updateBottomBarColor()
+            } ?: window.alert("Unable to load body")
+
+            document.body ?.appendElement("p", {})
+
             fun Element.updateCloudStorageContent() {
                 clear()
                 webApp.cloudStorage.getAll {
@@ -286,6 +319,16 @@ fun main() {
                     }
                     show()
                 }
+                secondaryButton.apply {
+                    setText("Secondary button")
+                    onClick {
+                        document.body ?.log("Secondary button clicked")
+                        hapticFeedback.notificationOccurred(
+                            HapticFeedbackType.Warning
+                        )
+                    }
+                    show()
+                }
                 onSettingsButtonClicked {
                     document.body ?.log("Settings button clicked")
                 }

WebApp/src/jvmMain/kotlin/WebAppServer.kt

@@ -1,44 +1,45 @@
-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.kslog.common.*
 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.*
+import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.extensions.api.send.send
 import dev.inmo.tgbotapi.extensions.api.telegramBot
-import dev.inmo.tgbotapi.extensions.behaviour_builder.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
-import dev.inmo.tgbotapi.extensions.utils.formatting.makeTelegramStartattach
-import dev.inmo.tgbotapi.extensions.utils.types.buttons.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onBaseInlineQuery
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onUnhandledCommand
+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.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.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.call
+import io.ktor.server.application.*
 import io.ktor.server.http.content.*
-import io.ktor.server.request.receiveText
-import io.ktor.server.response.respond
-import io.ktor.server.routing.post
-import io.ktor.server.routing.routing
+import io.ktor.server.request.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
 import kotlinx.coroutines.Dispatchers
 import kotlinx.serialization.json.Json
 import java.io.File
-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
  */
@@ -57,34 +58,48 @@ suspend fun main(vararg args: String) {
             }
         )
     }
+    val initiationLogger = KSLog("Initialization")
 
     val bot = telegramBot(telegramBotAPIUrlsKeeper)
     createKtorServer(
         "0.0.0.0",
-        args.getOrNull(2) ?.toIntOrNull() ?: 8080,
-        additionalEngineEnvironmentConfigurator = {
-            parentCoroutineContext += Dispatchers.IO
-        }
+        args.getOrNull(2) ?.toIntOrNull() ?: 8080
     ) {
         routing {
             val baseJsFolder = File("WebApp/build/dist/js/")
-            baseJsFolder.list() ?.forEach {
-                if (it == "productionExecutable" || it == "developmentExecutable") {
-                    staticFiles("", File(baseJsFolder, it)) {
-                        default("WebApp/build/dist/js/$it/index.html")
-                    }
+            val prodSubFolder = File(baseJsFolder, "productionExecutable")
+            val devSubFolder = File(baseJsFolder, "developmentExecutable")
+
+            val staticFolder = when {
+                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] ?: error("$webAppQueryIdField should be presented")
+                val queryId = call.parameters[webAppQueryIdField] ?.let(::InlineQueryId) ?: error("$webAppQueryIdField should be presented")
 
-                bot.answer(queryId, InlineQueryResultArticle(queryId, "Result", InputTextMessageContent(requestBody)))
+                bot.answerInlineQuery(queryId, listOf(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)
 
@@ -96,7 +111,6 @@ suspend fun main(vararg args: String) {
     bot.buildBehaviourWithLongPolling(
         defaultExceptionsHandler = { it.printStackTrace() }
     ) {
-        val me = getMe()
         onCommand("reply_markup") {
             reply(
                 it,

WebHooks/README.md

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

WebHooks/build.gradle

@@ -0,0 +1,23 @@
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: 'kotlin'
+apply plugin: 'application'
+
+mainClassName="WebHooksKt"
+
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
+    implementation "dev.inmo:micro_utils.ktor.server:$micro_utils_version"
+    implementation "io.ktor:ktor-server-cio:$ktor_version"
+}

WebHooks/src/main/kotlin/WebHooks.kt

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

gradle.properties

@@ -1,11 +1,12 @@
 kotlin.code.style=official
 org.gradle.parallel=true
 # Due to parallel compilation project require next amount of memory on full build
-org.gradle.jvmargs=-Xmx2344m
+org.gradle.jvmargs=-Xmx3148m
+kotlin.daemon.jvmargs=-Xmx3g -Xms500m
 
 
-kotlin_version=1.9.22
-telegram_bot_api_version=10.0.0
-micro_utils_version=0.20.26
-serialization_version=1.6.2
-ktor_version=2.3.7
+kotlin_version=2.0.21
+telegram_bot_api_version=19.1.0
+micro_utils_version=0.23.0
+serialization_version=1.7.3
+ktor_version=3.0.1

gradle/wrapper/gradle-wrapper.properties

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

settings.gradle

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