add toggle closing confirmation button

3.1.0

.github/workflows/build.yml

@@ -0,0 +1,16 @@
+name: Build
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up JDK 11
+        uses: actions/setup-java@v1
+        with:
+          java-version: 11
+      - name: Build with Gradle
+        run: ./gradlew build

.gitignore

@@ -8,3 +8,5 @@ settings.xml
 .gradle/
 build/
 out/
+
+kotlin-js-store/

.travis.yml

@@ -1,11 +0,0 @@
-language: java
-install: true
-
-os: linux
-dist: trusty
-jdk: oraclejdk8
-
-script:
-  - ./gradlew build -s
-  
-

FSMBot/README.md

@@ -0,0 +1,10 @@
+# FSM
+
+This bot contains an example of working with FSM included in project
+[MicroUtils](https://github.com/InsanusMokrassar/MicroUtils)
+
+## Launch
+
+```bash
+../gradlew run --args="BOT_TOKEN"
+```

FSMBot/build.gradle

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

FSMBot/src/main/kotlin/SimpleFSMBot.kt

@@ -0,0 +1,68 @@
+import dev.inmo.micro_utils.coroutines.AccumulatorFlow
+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.utils.formatting.*
+import dev.inmo.tgbotapi.types.ChatId
+import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
+import dev.inmo.tgbotapi.types.message.content.TextContent
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.first
+
+sealed interface BotState : State
+data class ExpectContentOrStopState(override val context: ChatId, val sourceMessage: CommonMessage<TextContent>) : BotState
+data class StopState(override val context: ChatId) : BotState
+
+suspend fun main(args: Array<String>) {
+    val botToken = args.first()
+
+    telegramBotWithBehaviourAndFSMAndStartLongPolling<BotState>(
+        botToken,
+        CoroutineScope(Dispatchers.IO),
+        onStateHandlingErrorHandler = { state, e ->
+            when (state) {
+                is ExpectContentOrStopState -> {
+                    println("Thrown error on ExpectContentOrStopState")
+                }
+                is StopState -> {
+                    println("Thrown error on StopState")
+                }
+            }
+            e.printStackTrace()
+            state
+        }
+    ) {
+        strictlyOn<ExpectContentOrStopState> {
+            sendMessage(
+                it.context,
+                buildEntities {
+                    +"Send me some content or " + botCommand("stop") + " if you want to stop sending"
+                }
+            )
+
+            val contentMessage = waitContentMessage().first()
+            val content = contentMessage.content
+
+            when {
+                content is TextContent && content.parseCommandsWithParams().keys.contains("stop") -> StopState(it.context)
+                else -> {
+                    execute(content.createResend(it.context))
+                    it
+                }
+            }
+        }
+        strictlyOn<StopState> {
+            send(it.context, "You have stopped sending of content")
+
+            null
+        }
+
+        command("start") {
+            startChain(ExpectContentOrStopState(it.chat.id, it))
+        }
+    }.second.join()
+}

FilesLoaderBot/build.gradle

@@ -1,6 +1,6 @@
 buildscript {
     repositories {
-        jcenter()
+        mavenCentral()
     }
 
     dependencies {
@@ -13,12 +13,8 @@ apply plugin: 'application'
 
 mainClassName="FilesLoaderBotKt"
 
-repositories {
-    jcenter()
-}
-
 dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
-    implementation "com.github.insanusmokrassar:TelegramBotAPI:$telegram_bot_api_version"
+    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
 }

FilesLoaderBot/src/main/kotlin/FilesLoaderBot.kt

@@ -1,14 +1,12 @@
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.api.downloadFile
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.api.get.getFileAdditionalInfo
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.api.telegramBot
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.flatMap
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.safely
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.shortcuts.*
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates.retrieving.startGettingFlowsUpdatesByLongPolling
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.abstracts.MediaContent
-import com.github.insanusmokrassar.TelegramBotAPI.utils.filenameFromUrl
-import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.*
+import dev.inmo.tgbotapi.extensions.api.files.downloadFile
+import dev.inmo.tgbotapi.extensions.api.get.getFileAdditionalInfo
+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.onMedia
+import dev.inmo.tgbotapi.utils.filenameFromUrl
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import java.io.File
 
 /**
@@ -16,27 +14,20 @@ import java.io.File
  */
 suspend fun main(args: Array<String>) {
     val botToken = args.first()
-    val directoryOrFile = args.getOrNull(1) ?.let { File(it) } ?: File("")
+    val directoryOrFile = args.getOrNull(1) ?.let { File(it) } ?: File("/tmp/")
     directoryOrFile.mkdirs()
 
-    val bot = telegramBot(botToken)
-    val scope = CoroutineScope(Dispatchers.Default)
-
-    bot.startGettingFlowsUpdatesByLongPolling(scope = scope) {
-        val flow = merge (
-            filterContentMessages<MediaContent>(),
-            mediaGroupMessages().flatMap()
-        )
-        flow.onEach {
-            safely({ it.printStackTrace() }) {
-                val pathedFile = bot.getFileAdditionalInfo(it.content.media)
-                File(directoryOrFile, pathedFile.filePath.filenameFromUrl).apply {
-                    createNewFile()
-                    writeBytes(bot.downloadFile(pathedFile))
-                }
+    telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO)) {
+        onMedia(initialFilter = null) {
+            val pathedFile = bot.getFileAdditionalInfo(it.content.media)
+            val outFile = File(directoryOrFile, pathedFile.filePath.filenameFromUrl)
+            runCatching {
+                bot.downloadFile(it.content.media, outFile)
+            }.onFailure {
+                it.printStackTrace()
             }
-        }.launchIn(scope)
-    }
-
-    scope.coroutineContext[Job]!!.join()
+            reply(it, "Saved to ${outFile.absolutePath}")
+        }
+        onContentMessage { println(it) }
+    }.second.join()
 }

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

ForwardInfoSenderBot/src/main/kotlin/ForwardInfoSenderBot.kt

@@ -0,0 +1,48 @@
+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.utils.formatting.*
+import dev.inmo.tgbotapi.types.chat.CommonBot
+import dev.inmo.tgbotapi.types.chat.CommonUser
+import dev.inmo.tgbotapi.types.chat.ExtendedBot
+import dev.inmo.tgbotapi.types.message.*
+import kotlinx.coroutines.*
+
+/**
+ * This bot will always return message about forwarder. In cases when sent message was not a forward message it will
+ * send suitable message
+ */
+suspend fun main(vararg args: String) {
+    val botToken = args.first()
+
+    telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO)) {
+        onContentMessage {
+            val toAnswer = buildEntities {
+                when (val forwardInfo = it.forwardInfo) {
+                    null -> +"There is no forward info"
+                    is ForwardInfo.ByAnonymous -> {
+                        regular("Anonymous user which signed as \"") + code(forwardInfo.senderName) + "\""
+                    }
+                    is ForwardInfo.ByUser -> {
+                        val user = forwardInfo.from
+                        when (user) {
+                            is CommonUser -> {
+                                if (user.isPremium) {
+                                    regular("Premium user ")
+                                } else {
+                                    regular("User ")
+                                }
+                            }
+                            is CommonBot,
+                            is ExtendedBot -> regular("Bot ")
+                        } + code(user.id.chatId.toString()) + " (${user.firstName} ${user.lastName}: ${user.username ?.username ?: "Without username"})"
+                    }
+                    is ForwardInfo.PublicChat.FromChannel -> regular("Channel (") + code(forwardInfo.channelChat.title) + ")"
+                    is ForwardInfo.PublicChat.FromSupergroup -> regular("Supergroup (") + code(forwardInfo.group.title) + ")"
+                    is ForwardInfo.PublicChat.SentByChannel -> regular("Sent by channel (") + code(forwardInfo.channelChat.title) + ")"
+                }
+            }
+            reply(it, toAnswer)
+        }
+    }.second.join()
+}

ForwarderBot/build.gradle

@@ -1,24 +0,0 @@
-buildscript {
-    repositories {
-        jcenter()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-apply plugin: 'kotlin'
-apply plugin: 'application'
-
-mainClassName="ForwarderBotKt"
-
-repositories {
-    jcenter()
-}
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
-
-    implementation "com.github.insanusmokrassar:TelegramBotAPI:$telegram_bot_api_version"
-}

ForwarderBot/src/main/kotlin/ForwarderBot.kt

@@ -1,43 +0,0 @@
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.api.send.sendTextMessage
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.api.telegramBot
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.formatting.codeMarkdownV2
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.formatting.regularMarkdownV2
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.safely
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates.asContentMessagesFlow
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates.retrieving.startGettingFlowsUpdatesByLongPolling
-import com.github.insanusmokrassar.TelegramBotAPI.types.ParseMode.MarkdownV2
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.PossiblyForwardedMessage
-import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.*
-
-/**
- * This bot will always return message about forwarder. In cases when sent message was not a forward message it will
- * send suitable message
- */
-suspend fun main(vararg args: String) {
-    val botToken = args.first()
-
-    val bot = telegramBot(botToken)
-
-    val scope = CoroutineScope(Dispatchers.Default)
-
-    bot.startGettingFlowsUpdatesByLongPolling(scope = scope) {
-        messageFlow.asContentMessagesFlow().mapNotNull { it as? PossiblyForwardedMessage }.onEach { message ->
-            safely({ it.printStackTrace() }) {
-                val toAnswer = when (val forwardInfo = message.forwardInfo) {
-                    null -> "There is no forward info"
-                    is AnonymousForwardInfo -> "Anonymous user which signed as \"${forwardInfo.senderName.codeMarkdownV2()}\""
-                    is UserForwardInfo -> forwardInfo.from.let { user ->
-                        "User ${user.id.chatId.toString().codeMarkdownV2()} " + "(${user.firstName} ${user.lastName}: ${user.username ?.username ?: "Without username"})".regularMarkdownV2()
-                    }
-                    is ForwardFromChannelInfo -> "Channel (".regularMarkdownV2() + (forwardInfo.channelChat).title.codeMarkdownV2() + ")".regularMarkdownV2()
-                    is ForwardFromSupergroupInfo -> "Supergroup (".regularMarkdownV2() + (forwardInfo.group).title.codeMarkdownV2() + ")".regularMarkdownV2()
-                }
-                bot.sendTextMessage(message.chat, toAnswer, MarkdownV2)
-            }
-        }.launchIn(scope)
-    }
-
-    scope.coroutineContext[Job]!!.join()
-}

GetMeBot/build.gradle

@@ -1,6 +1,6 @@
 buildscript {
     repositories {
-        jcenter()
+        mavenCentral()
     }
 
     dependencies {
@@ -13,12 +13,9 @@ apply plugin: 'application'
 
 mainClassName="HelloBotKt"
 
-repositories {
-    jcenter()
-}
 
 dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
-    implementation "com.github.insanusmokrassar:TelegramBotAPI:$telegram_bot_api_version"
+    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
 }

GetMeBot/src/main/kotlin/GetMeBot.kt

@@ -1,5 +1,5 @@
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.api.bot.getMe
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.api.telegramBot
+import dev.inmo.tgbotapi.bot.ktor.telegramBot
+import dev.inmo.tgbotapi.extensions.api.bot.getMe
 
 /**
  * This is one of the most easiest bot - it will just print information about itself
@@ -10,4 +10,4 @@ suspend fun main(vararg args: String) {
     val bot = telegramBot(botToken)
 
     println(bot.getMe())
-}
+}

HelloBot/build.gradle

@@ -1,6 +1,6 @@
 buildscript {
     repositories {
-        jcenter()
+        mavenCentral()
     }
 
     dependencies {
@@ -13,12 +13,9 @@ apply plugin: 'application'
 
 mainClassName="HelloBotKt"
 
-repositories {
-    jcenter()
-}
 
 dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
-    implementation "com.github.insanusmokrassar:TelegramBotAPI:$telegram_bot_api_version"
+    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
 }

HelloBot/src/main/kotlin/HelloBot.kt

@@ -1,54 +1,51 @@
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.api.chat.get.getChat
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.api.send.sendTextMessage
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.api.telegramBot
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.formatting.linkMarkdownV2
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.formatting.textMentionMarkdownV2
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.safely
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates.retrieving.startGettingFlowsUpdatesByLongPolling
-import com.github.insanusmokrassar.TelegramBotAPI.types.ParseMode.MarkdownV2
-import com.github.insanusmokrassar.TelegramBotAPI.types.User
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.*
-import com.github.insanusmokrassar.TelegramBotAPI.utils.extensions.escapeMarkdownV2Common
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
+import dev.inmo.tgbotapi.extensions.api.send.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
+import dev.inmo.tgbotapi.extensions.utils.formatting.linkMarkdownV2
+import dev.inmo.tgbotapi.extensions.utils.formatting.textMentionMarkdownV2
+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.flow.launchIn
-import kotlinx.coroutines.flow.onEach
 
 /**
  * The main purpose of this bot is just to answer "Oh, hi, " and add user mention here
  */
+@OptIn(PreviewFeature::class)
 suspend fun main(vararg args: String) {
     val botToken = args.first()
 
-    val bot = telegramBot(botToken)
-
-    val scope = CoroutineScope(Dispatchers.Default)
-
-    bot.startGettingFlowsUpdatesByLongPolling(scope = scope) {
-        messageFlow.onEach {
-            safely {
-                val chat = it.data.chat
-                val message = "Oh, hi, " + when (chat) {
-                    is PrivateChat -> "${chat.firstName} ${chat.lastName}".textMentionMarkdownV2(chat.id)
-                    is User -> "${chat.firstName} ${chat.lastName}".textMentionMarkdownV2(chat.id)
-                    is SupergroupChat -> (chat.username ?.username ?: bot.getChat(chat).inviteLink) ?.let {
-                        chat.title.linkMarkdownV2(it)
-                    } ?: chat.title
-                    is GroupChat -> bot.getChat(chat).inviteLink ?.let {
-                        chat.title.linkMarkdownV2(it)
-                    } ?: chat.title
-                    else -> "Unknown :(".escapeMarkdownV2Common()
-                }
-                bot.sendTextMessage(chat, message, MarkdownV2)
+    telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO)) {
+        onContentMessage { message ->
+            val chat = message.chat
+            if (chat is ChannelChat) {
+                val answer = "Hi everybody in this channel \"${chat.title}\""
+                send(chat, answer, MarkdownV2)
+                return@onContentMessage
             }
-        }.launchIn(scope)
-        channelPostFlow.onEach {
-            safely {
-                val chat = it.data.chat
-                val message = "Hi everybody in this channel \"${(chat as ChannelChat).title}\""
-                bot.sendTextMessage(chat, message, MarkdownV2)
+            val answerText = "Oh, hi, " + when (chat) {
+                is User -> "${chat.firstName} ${chat.lastName}".textMentionMarkdownV2(chat.id)
+                is PrivateChat -> "${chat.firstName} ${chat.lastName}".textMentionMarkdownV2(chat.id)
+                is SupergroupChat -> (chat.username ?.username ?: getChat(chat).inviteLink) ?.let {
+                    chat.title.linkMarkdownV2(it)
+                } ?: chat.title
+                is GroupChat -> bot.getChat(chat).inviteLink ?.let {
+                    chat.title.linkMarkdownV2(it)
+                } ?: chat.title
+                else -> "Unknown :(".escapeMarkdownV2Common()
             }
-        }.launchIn(scope)
-    }
-
-    scope.coroutineContext[Job]!!.join()
-}
+            reply(
+                message,
+                answerText,
+                MarkdownV2
+            )
+        }
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) { println(it) }
+    }.second.join()
+}

KeyboardsBot/KeyboardsBotLib/build.gradle

@@ -0,0 +1,32 @@
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+}
+
+
+kotlin {
+    jvm()
+    js(IR) {
+        browser()
+        binaries.executable()
+    }
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation kotlin('stdlib')
+
+                api "dev.inmo:tgbotapi:$telegram_bot_api_version"
+            }
+        }
+    }
+}

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

@@ -0,0 +1,126 @@
+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.setMyCommands
+import dev.inmo.tgbotapi.extensions.api.edit.edit
+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.extensions.utils.formatting.botCommand
+import dev.inmo.tgbotapi.extensions.utils.formatting.buildEntities
+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.message.content.TextContent
+import kotlinx.coroutines.*
+
+private const val nextPageData = "next"
+private const val previousPageData = "previous"
+
+fun String.parsePageAndCount(): Pair<Int, Int>? {
+    val (pageString, countString) = split(" ").takeIf { it.count() > 1 } ?: return null
+    return Pair(
+        pageString.toIntOrNull() ?: return null,
+        countString.toIntOrNull() ?: return null
+    )
+}
+
+fun InlineKeyboardBuilder.includePageButtons(page: Int, count: Int) {
+    val numericButtons = listOfNotNull(
+        page - 1,
+        page,
+        page + 1,
+    )
+    row {
+        val numbersRange = 1 .. count
+        numericButtons.forEach {
+            if (it in numbersRange) {
+                dataButton(it.toString(), "$it $count")
+            }
+        }
+    }
+
+    row {
+        if (page - 1 > 2) {
+            dataButton("<<", "1 $count")
+        }
+        if (page - 1 > 1) {
+            dataButton("<", "${page - 2} $count")
+        }
+
+        if (page + 1 < count) {
+            dataButton(">", "${page + 2} $count")
+        }
+        if (page + 2 < count) {
+            dataButton(">>", "$count $count")
+        }
+    }
+}
+
+suspend fun activateKeyboardsBot(
+    token: String,
+    print: (Any) -> Unit
+) {
+    val bot = telegramBot(token)
+
+    print(bot.getMe())
+
+    bot.buildBehaviourWithLongPolling(CoroutineScope(currentCoroutineContext() + SupervisorJob())) {
+        onCommandWithArgs("inline") { message, args ->
+            val numberOfPages = args.firstOrNull() ?.toIntOrNull() ?: 10
+            reply(
+                message,
+                "Your inline keyboard with $numberOfPages pages",
+                replyMarkup = inlineKeyboard {
+                    row {
+                        includePageButtons(1, numberOfPages)
+                    }
+                }
+            )
+        }
+
+        onMessageDataCallbackQuery {
+            val (page, count) = it.data.parsePageAndCount() ?: it.let {
+                answer(it, "Unsupported data :(")
+                return@onMessageDataCallbackQuery
+            }
+
+            val text = "This is $page of $count"
+
+            edit(
+                it.message.withContent<TextContent>() ?: it.let {
+                    answer(it, "Unsupported message type :(")
+                    return@onMessageDataCallbackQuery
+                },
+                text,
+                replyMarkup = inlineKeyboard {
+                    row {
+                        includePageButtons(page, count)
+                    }
+                }
+            )
+            answer(it)
+        }
+
+        onUnhandledCommand {
+            reply(
+                it,
+                buildEntities {
+                    +"Use " + botCommand("inline") + " to get pagination inline keyboard"
+                },
+                replyMarkup = replyKeyboard(resizeKeyboard = true, oneTimeKeyboard = true) {
+                    row {
+                        simpleButton("/inline")
+                    }
+                }
+            )
+        }
+
+        setMyCommands(BotCommand("inline", "Creates message with pagination inline keyboard"))
+
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
+            println(it)
+        }
+    }.join()
+}

KeyboardsBot/KeyboardsBotLib/src/jsMain/kotlin/KeyboardsBot.kt

@@ -0,0 +1,32 @@
+import kotlinx.browser.document
+import kotlinx.coroutines.*
+import org.w3c.dom.*
+
+private val scope = CoroutineScope(Dispatchers.Default)
+
+fun main() {
+    document.addEventListener(
+        "DOMContentLoaded",
+        {
+            val botsContainer = document.getElementById("bots_container") ?: return@addEventListener
+
+            (document.getElementById("bot_token_form") as? HTMLFormElement) ?.onsubmit = {
+                (document.getElementById("bot_token") as? HTMLInputElement) ?.value ?.let { token ->
+                    val botContainer = document.createElement("div") as HTMLDivElement
+                    botsContainer.append(botContainer)
+
+                    val infoDiv = document.createElement("div") as HTMLDivElement
+                    botContainer.append(infoDiv)
+
+                    scope.launch {
+                        activateKeyboardsBot(token) {
+                            infoDiv.innerHTML = it.toString()
+                        }
+                    }
+                }
+
+                false
+            }
+        }
+    )
+}

KeyboardsBot/KeyboardsBotLib/src/jsMain/resources/index.html

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Keyboards bot</title>
+</head>
+<body>
+    <form id="bot_token_form">
+        <input type="text" id="bot_token">
+        <input type="submit" value="Start bot">
+    </form>
+    <div id="start_offer">Type your bot token to the input above to start its work</div>
+    <script type="text/javascript" src="KeyboardsBotLib.js"></script>
+    <div id="bots_container"></div>
+</body>
+</html>

KeyboardsBot/jvm_launcher/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="KeyboardsBotJvmKt"
+
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+    implementation project(":KeyboardsBot:KeyboardsBotLib")
+}

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

@@ -0,0 +1,10 @@
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+suspend fun main(args: Array<String>) {
+    withContext(Dispatchers.IO) { // IO for inheriting of it in side of activateKeyboardsBot
+        activateKeyboardsBot(args.first()) {
+            println(it)
+        }
+    }
+}

README.md

@@ -1,2 +1,32 @@
 # TelegramBotAPI-examples
+
 This repository contains several examples of simple bots which are using TelegramBotAPI
+
+## How to use this repository
+
+This repository contains several important things:
+
+* Example subprojects
+* Commits
+* Structure
+
+### Example subproject
+
+Each example subproject contains information about how to run this example and what is it
+doing. Usually, it is some simple thing like sending "hello" message to the user which
+wrote to the bot.
+
+### Commits
+
+Commits can contains some things like migration onto new version (especially it is actual
+for major version changes), updates according to the new features in versions and
+different other things which usually more important in context of history or changes
+between library version
+
+### Structure
+
+Structure of this repository fully representative (it is the reason why this repo
+contains multiplatform subprojects) and you can use it as some template (but I am strongly
+recommend you to use my
+[TelegramBot template](https://github.com/InsanusMokrassar/TelegramBotAPI-bot_template) or
+[Multiplatform Project template](https://github.com/InsanusMokrassar/KotlinMultiplatformProjectTemplate))

RandomFileSenderBot/build.gradle

@@ -1,6 +1,6 @@
 buildscript {
     repositories {
-        jcenter()
+        mavenCentral()
     }
 
     dependencies {
@@ -13,12 +13,9 @@ apply plugin: 'application'
 
 mainClassName="RandomFileSenderBotKt"
 
-repositories {
-    jcenter()
-}
 
 dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
-    implementation "com.github.insanusmokrassar:TelegramBotAPI:$telegram_bot_api_version"
+    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
 }

RandomFileSenderBot/src/main/kotlin/RandomFileSenderBot.kt

@@ -1,22 +1,29 @@
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.api.bot.getMe
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.api.bot.setMyCommands
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.api.send.media.sendDocument
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.api.send.sendTextMessage
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.api.telegramBot
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.safely
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates.filterExactCommands
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates.retrieving.startGettingFlowsUpdatesByLongPolling
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.toInputFile
-import com.github.insanusmokrassar.TelegramBotAPI.types.BotCommand
-import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.onEach
+import dev.inmo.micro_utils.common.filesize
+import dev.inmo.tgbotapi.bot.ktor.telegramBot
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.extensions.api.bot.getMe
+import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
+import dev.inmo.tgbotapi.extensions.api.send.*
+import dev.inmo.tgbotapi.extensions.api.send.media.sendDocument
+import dev.inmo.tgbotapi.extensions.api.send.media.sendDocumentsGroup
+import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommandWithArgs
+import dev.inmo.tgbotapi.requests.abstracts.asMultipartFile
+import dev.inmo.tgbotapi.types.BotCommand
+import dev.inmo.tgbotapi.types.chat.Chat
+import dev.inmo.tgbotapi.types.files.DocumentFile
+import dev.inmo.tgbotapi.types.media.TelegramMediaDocument
+import dev.inmo.tgbotapi.types.mediaCountInMediaGroup
 import java.io.File
 
 private const val command = "send_file"
 
 /**
- * This bot will send files inside of working directory OR from directory in the second argument
+ * This bot will send files inside of working directory OR from directory in the second argument.
+ * You may send /send_file command to this bot to get random file from the directory OR
+ * `/send_file $number` when you want to receive required number of files. For example,
+ * /send_file and `/send_file 1` will have the same effect - bot will send one random file.
+ * But if you will send `/send_file 5` it will choose 5 random files and send them as group
  */
 suspend fun main(args: Array<String>) {
     val botToken = args.first()
@@ -26,32 +33,63 @@ suspend fun main(args: Array<String>) {
         if (currentRoot.isFile) {
             return currentRoot
         } else {
-            return pickFile(currentRoot.listFiles() ?.random() ?: return null)
+            return pickFile(currentRoot.listFiles() ?.takeIf { it.isNotEmpty() } ?.random() ?: return null)
+        }
+    }
+
+    suspend fun TelegramBot.sendFiles(chat: Chat, files: List<File>) {
+        when (files.size) {
+            1 -> sendDocument(
+                chat.id,
+                files.first().asMultipartFile(),
+                protectContent = true
+            )
+            else -> sendDocumentsGroup(
+                chat,
+                files.map { TelegramMediaDocument(it.asMultipartFile()) },
+                protectContent = true
+            )
         }
     }
 
     val bot = telegramBot(botToken)
-    val scope = CoroutineScope(Dispatchers.Default)
 
-    bot.startGettingFlowsUpdatesByLongPolling(scope = scope) {
-        messageFlow.filterExactCommands(Regex(command)).onEach { message ->
-            safely {
-                pickFile() ?.let {
-                    bot.sendDocument(
-                        message.chat.id,
-                        it.toInputFile()
-                    )
-                } ?: bot.sendTextMessage(message.chat.id, "Nothing selected :(")
+    bot.buildBehaviourWithLongPolling (defaultExceptionsHandler = { it.printStackTrace() }) {
+        onCommandWithArgs(command) { message, args ->
+
+            withUploadDocumentAction(message.chat) {
+                val count = args.firstOrNull() ?.toIntOrNull() ?: 1
+                var sent = false
+
+                var left = count
+                val chosen = mutableListOf<File>()
+
+                while (left > 0) {
+                    val picked = pickFile() ?.takeIf { it.filesize > 0 } ?: continue
+                    chosen.add(picked)
+                    left--
+                    if (chosen.size >= mediaCountInMediaGroup.last) {
+                        sendFiles(message.chat, chosen)
+                        chosen.clear()
+                        sent = true
+                    }
+                }
+
+                if (chosen.isNotEmpty()) {
+                    sendFiles(message.chat, chosen)
+                    sent = true
+                }
+
+                if (!sent) {
+                    reply(message, "Nothing selected :(")
+                }
             }
-        }.launchIn(scope)
-    }
+        }
 
-    safely {
-        bot.setMyCommands(
+        setMyCommands(
             BotCommand(command, "Send some random file in picker directory")
         )
-        println(bot.getMe())
-    }
 
-    scope.coroutineContext[Job]!!.join()
+        println(getMe())
+    }.join()
 }

ResenderBot/ResenderBotLib/build.gradle

@@ -1,6 +1,6 @@
 buildscript {
     repositories {
-        jcenter()
+        mavenCentral()
     }
 
     dependencies {
@@ -9,15 +9,13 @@ buildscript {
 }
 
 plugins {
-    id "org.jetbrains.kotlin.multiplatform" version "$kotlin_version"
+    id "org.jetbrains.kotlin.multiplatform"
 }
 
-repositories {
-    jcenter()
-}
 
 kotlin {
     jvm()
+//    js(LEGACY) {
     js(IR) {
         browser()
         binaries.executable()
@@ -28,7 +26,7 @@ kotlin {
             dependencies {
                 implementation kotlin('stdlib')
 
-                api "com.github.insanusmokrassar:TelegramBotAPI:$telegram_bot_api_version"
+                api "dev.inmo:tgbotapi:$telegram_bot_api_version"
             }
         }
     }

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

@@ -1,14 +1,14 @@
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.api.bot.getMe
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.api.send.media.sendMediaGroup
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.api.telegramBot
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.safely
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.shortcuts.*
-import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates.retrieving.startGettingFlowsUpdatesByLongPolling
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.abstracts.MediaGroupContent
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.abstracts.MessageContent
+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.behaviour_builder.filters.MessageFilterByChat
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
+import dev.inmo.tgbotapi.extensions.utils.shortcuts.*
 import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.onEach
 
 suspend fun activateResenderBot(
     token: String,
@@ -18,26 +18,39 @@ suspend fun activateResenderBot(
 
     print(bot.getMe())
 
-    supervisorScope {
-        val scope = this
-        bot.startGettingFlowsUpdatesByLongPolling {
-            filterContentMessages<MessageContent>(scope).onEach {
-                it.content.createResends(it.chat.id, replyToMessageId = it.messageId).forEach {
-                    bot.executeUnsafe(it) {
-                        it.forEach(print)
-                    } ?.also {
-                        print(it)
-                    }
+    bot.buildBehaviourWithLongPolling(CoroutineScope(currentCoroutineContext() + SupervisorJob())) {
+        onContentMessage(
+            initialFilter = CommonMessageFilterExcludeMediaGroups,
+            subcontextUpdatesFilter = MessageFilterByChat
+        ) {
+            val chat = it.chat
+            withTypingAction(chat) {
+                executeUnsafe(it.content.createResend(chat.id, replyToMessageId = it.messageId)) {
+                    it.forEach(print)
                 }
-            }.launchIn(scope)
-            mediaGroupMessages(scope).onEach {
-                safely({ print(it.stackTraceToString()) }) {
-                    println(it.chat)
-                    bot.execute(it.createResend(it.chat ?: return@safely, replyTo = it.first().messageId)).also {
-                        print(it)
-                    }
-                }
-            }.launchIn(scope)
+            }
         }
-    }
+        onVisualGallery {
+            val chat = it.chat ?: return@onVisualGallery
+            withUploadPhotoAction(chat) {
+                send(chat, it.map { it.content.toMediaGroupMemberTelegramMedia() })
+            }
+        }
+        onPlaylist {
+            val chat = it.chat ?: return@onPlaylist
+            withUploadDocumentAction(chat) {
+                send(chat, it.map { it.content.toMediaGroupMemberTelegramMedia() })
+            }
+        }
+        onDocumentsGroup {
+            val chat = it.chat ?: return@onDocumentsGroup
+            withUploadDocumentAction(chat) {
+                send(chat, it.map { it.content.toMediaGroupMemberTelegramMedia() })
+            }
+        }
+
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
+            println(it)
+        }
+    }.join()
 }

ResenderBot/jvm_launcher/build.gradle

@@ -1,6 +1,6 @@
 buildscript {
     repositories {
-        jcenter()
+        mavenCentral()
     }
 
     dependencies {
@@ -13,12 +13,9 @@ apply plugin: 'application'
 
 mainClassName="ResenderBotJvmKt"
 
-repositories {
-    jcenter()
-}
 
 dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
     implementation project(":ResenderBot:ResenderBotLib")
 }

SlotMachineDetectorBot/README.md

@@ -0,0 +1,9 @@
+# SlotMachineDetectorBot
+
+This bot must reply with information about slot machine answer
+
+## Launch
+
+```bash
+../gradlew run --args="BOT_TOKEN"
+```

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

SlotMachineDetectorBot/src/main/kotlin/SlotMachineDetectorBot.kt

@@ -0,0 +1,26 @@
+import dev.inmo.tgbotapi.bot.ktor.telegramBot
+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.onDice
+import dev.inmo.tgbotapi.extensions.utils.*
+import dev.inmo.tgbotapi.types.dice.SlotMachineDiceAnimationType
+import kotlinx.coroutines.*
+
+suspend fun main(args: Array<String>) {
+    val bot = telegramBot(args.first())
+
+    bot.buildBehaviourWithLongPolling(scope = CoroutineScope(Dispatchers.IO)) {
+        onDice {
+            val content = it.content
+            val dice = content.dice
+            val diceType = dice.animationType
+
+            if (diceType == SlotMachineDiceAnimationType) {
+                val result = dice.calculateSlotMachineResult() ?: return@onDice
+                reply(it, "${result.leftReel}|${result.centerReel}|${result.rightReel}")
+            } else {
+                reply(it, "There is no slot machine dice in message")
+            }
+        }
+    }.join()
+}

StickerInfoBot/StickerInfoBotLib/build.gradle

@@ -0,0 +1,33 @@
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+}
+
+
+kotlin {
+    jvm()
+//    js(LEGACY) {
+    js(IR) {
+        browser()
+        binaries.executable()
+    }
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation kotlin('stdlib')
+
+                api "dev.inmo:tgbotapi:$telegram_bot_api_version"
+            }
+        }
+    }
+}

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

@@ -0,0 +1,71 @@
+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.getCustomEmojiStickerOrNull
+import dev.inmo.tgbotapi.extensions.api.get.getStickerSet
+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.extensions.utils.formatting.*
+import dev.inmo.tgbotapi.types.StickerType
+import dev.inmo.tgbotapi.types.message.textsources.*
+import dev.inmo.tgbotapi.types.stickers.StickerSet
+import kotlinx.coroutines.*
+
+fun StickerSet.buildInfo() = buildEntities {
+    bold("StickerSet name: ") + "${name}\n"
+    bold("StickerSet title: ") + "${title}\n"
+    bold(
+        when (stickerType) {
+            StickerType.CustomEmoji -> "Custom emoji"
+            StickerType.Mask -> "Mask"
+            StickerType.Regular -> "Regular"
+            is StickerType.Unknown -> "Unknown type \"${stickerType.type}\""
+        }
+    ) + " sticker set with title " + bold(title) + " and name " + bold(name)
+}
+
+suspend fun activateStickerInfoBot(
+    token: String,
+    print: (Any) -> Unit
+) {
+    val bot = telegramBot(token)
+
+    print(bot.getMe())
+
+    defaultSafelyWithoutExceptionHandler = {
+        it.printStackTrace()
+    }
+
+    bot.buildBehaviourWithLongPolling(CoroutineScope(currentCoroutineContext() + SupervisorJob())) {
+        onText {
+            withTypingAction(it.chat) {
+                it.content.textSources.mapNotNull {
+                    if (it is CustomEmojiTextSource) {
+                        getCustomEmojiStickerOrNull(it.customEmojiId) ?.stickerSetName
+                    } else {
+                        null
+                    }
+                }.distinct().map {
+                    getStickerSet(it)
+                }.distinct().flatMap {
+                    it.buildInfo() + regular("\n")
+                }.separateForText().map { entities ->
+                    reply(it, entities)
+                }
+            }
+        }
+        onSticker {
+            val stickerSetInfo = getStickerSet(it.content.media)
+            reply(
+                it,
+                stickerSetInfo.buildInfo()
+            )
+        }
+
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
+            println(it)
+        }
+    }.join()
+}

StickerInfoBot/StickerInfoBotLib/src/jsMain/kotlin/StickerInfoBot.kt

@@ -0,0 +1,32 @@
+import kotlinx.browser.document
+import kotlinx.coroutines.*
+import org.w3c.dom.*
+
+private val scope = CoroutineScope(Dispatchers.Default)
+
+fun main() {
+    document.addEventListener(
+        "DOMContentLoaded",
+        {
+            val botsContainer = document.getElementById("bots_container") ?: return@addEventListener
+
+            (document.getElementById("bot_token_form") as? HTMLFormElement) ?.onsubmit = {
+                (document.getElementById("bot_token") as? HTMLInputElement) ?.value ?.let { token ->
+                    val botContainer = document.createElement("div") as HTMLDivElement
+                    botsContainer.append(botContainer)
+
+                    val infoDiv = document.createElement("div") as HTMLDivElement
+                    botContainer.append(infoDiv)
+
+                    scope.launch {
+                        activateStickerInfoBot(token) {
+                            infoDiv.innerHTML = it.toString()
+                        }
+                    }
+                }
+
+                false
+            }
+        }
+    )
+}

StickerInfoBot/StickerInfoBotLib/src/jsMain/resources/index.html

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Resender bot</title>
+</head>
+<body>
+    <form id="bot_token_form">
+        <input type="text" id="bot_token">
+        <input type="submit" value="Start bot">
+    </form>
+    <div id="start_offer">Type your bot token to the input above to start its work</div>
+    <script type="text/javascript" src="StickerInfoBotLib.js"></script>
+    <div id="bots_container"></div>
+</body>
+</html>

StickerInfoBot/jvm_launcher/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="StickerInfoBotJvmKt"
+
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+    implementation project(":StickerInfoBot:StickerInfoBotLib")
+}

StickerInfoBot/jvm_launcher/src/main/kotlin/StickerInfoBotBotJvm.kt

@@ -0,0 +1,5 @@
+suspend fun main(args: Array<String>) {
+    activateStickerInfoBot(args.first()) {
+        println(it)
+    }
+}

WebApp/README.md

@@ -0,0 +1,17 @@
+# WebApp
+
+Here you may find simple example of `WebApp`. For work of this example you will need one of two things:
+
+* Your own domain with SSL (letsencrypt is okay)
+* Test account in telegram
+
+What is there in this module:
+
+* JVM part of this example is a server with simple static webapp sharing and bot which just gives the webapp button to open webapp
+* JS part is the WebApp with one button and reacting to chaged user theme and app viewport
+
+## How to run
+
+```kotlin
+./gradlew run --args="TOKEN WEB_APP_ADDRESS"
+```

WebApp/build.gradle

@@ -0,0 +1,57 @@
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+}
+
+apply plugin: 'application'
+
+kotlin {
+    jvm()
+    js(IR) {
+        browser()
+        binaries.executable()
+    }
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation kotlin('stdlib')
+                implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:$serialization_version"
+            }
+        }
+
+        jsMain {
+            dependencies {
+                implementation "dev.inmo:tgbotapi.webapps:$telegram_bot_api_version"
+            }
+        }
+
+        jvmMain {
+            dependencies {
+                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"
+            }
+        }
+    }
+}
+
+application {
+    mainClassName = "WebAppServerKt"
+}
+
+tasks.getByName("compileKotlinJvm")
+        .dependsOn(jsBrowserDistribution)
+tasks.getByName("compileKotlinJvm").configure {
+    mustRunAfter jsBrowserDistribution
+}

WebApp/src/commonMain/kotlin/WebAppDataWrapper.kt

@@ -0,0 +1,7 @@
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class WebAppDataWrapper(
+    val data: String,
+    val hash: String
+)

WebApp/src/jsMain/kotlin/main.kt

@@ -0,0 +1,180 @@
+import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
+import dev.inmo.tgbotapi.types.webAppQueryIdField
+import dev.inmo.tgbotapi.webapps.*
+import dev.inmo.tgbotapi.webapps.haptic.HapticFeedbackStyle
+import dev.inmo.tgbotapi.webapps.haptic.HapticFeedbackType
+import dev.inmo.tgbotapi.webapps.popup.*
+import io.ktor.client.HttpClient
+import io.ktor.client.request.*
+import io.ktor.client.statement.bodyAsText
+import io.ktor.http.*
+import io.ktor.http.content.TextContent
+import kotlinx.browser.document
+import kotlinx.browser.window
+import kotlinx.coroutines.*
+import kotlinx.dom.appendElement
+import kotlinx.dom.appendText
+import kotlinx.serialization.json.Json
+import org.w3c.dom.HTMLElement
+
+fun HTMLElement.log(text: String) {
+    appendText(text)
+    appendElement("p", {})
+}
+
+fun main() {
+    console.log("Web app started")
+    val client = HttpClient()
+    val baseUrl = window.location.origin.removeSuffix("/")
+
+    window.onload = {
+        val scope = CoroutineScope(Dispatchers.Default)
+        runCatching {
+
+            scope.launchSafelyWithoutExceptions {
+                val response = client.post("$baseUrl/check") {
+                    setBody(
+                        Json { }.encodeToString(
+                            WebAppDataWrapper.serializer(),
+                            WebAppDataWrapper(webApp.initData, webApp.initDataUnsafe.hash)
+                        )
+                    )
+                }
+                val dataIsSafe = response.bodyAsText().toBoolean()
+
+                document.body ?.log(
+                    if (dataIsSafe) {
+                        "Data is safe"
+                    } else {
+                        "Data is unsafe"
+                    }
+                )
+
+                document.body ?.log(
+                    webApp.initDataUnsafe.chat.toString()
+                )
+            }
+
+            document.body ?.appendElement("button") {
+                addEventListener("click", {
+                    scope.launchSafelyWithoutExceptions {
+                        handleResult({ "Clicked" }) {
+                            client.post("${window.location.origin.removeSuffix("/")}/inline") {
+                                parameter(webAppQueryIdField, it)
+                                setBody(TextContent("Clicked", ContentType.Text.Plain))
+                                document.body ?.log(url.build().toString())
+                            }.coroutineContext.job.join()
+                        }
+                    }
+                })
+                appendText("Example button")
+            } ?: window.alert("Unable to load body")
+
+            document.body ?.appendElement("p", {})
+            document.body ?.appendText("Alerts:")
+
+            document.body ?.appendElement("button") {
+                addEventListener("click", {
+                    webApp.showPopup(
+                        PopupParams(
+                            "It is sample title of default button",
+                            "It is sample message of default button",
+                            DefaultPopupButton("default", "Default button"),
+                            OkPopupButton("ok"),
+                            DestructivePopupButton("destructive", "Destructive button")
+                        )
+                    ) {
+                        document.body ?.log(
+                            when (it) {
+                                "default" -> "You have clicked default button in popup"
+                                "ok" -> "You have clicked ok button in popup"
+                                "destructive" -> "You have clicked destructive button in popup"
+                                else -> "I can't imagine where you take button with id $it"
+                            }
+                        )
+                    }
+                })
+                appendText("Popup")
+            } ?: window.alert("Unable to load body")
+
+            document.body ?.appendElement("button") {
+                addEventListener("click", {
+                    webApp.showAlert(
+                        "This is alert message"
+                    ) {
+                        document.body ?.log(
+                            "You have closed alert"
+                        )
+                    }
+                })
+                appendText("Alert")
+            } ?: window.alert("Unable to load body")
+
+            document.body ?.appendElement("button") {
+                addEventListener("click", {
+                    webApp.showConfirm(
+                        "This is confirm message"
+                    ) {
+                        document.body ?.log(
+                            "You have pressed \"${if (it) "Ok" else "Cancel"}\" in confirm"
+                        )
+                    }
+                })
+                appendText("Confirm")
+            } ?: window.alert("Unable to load body")
+
+            document.body ?.appendElement("p", {})
+
+            document.body ?.appendElement("button") {
+                fun updateText() {
+                    textContent = if (webApp.isClosingConfirmationEnabled) {
+                        "Disable closing confirmation"
+                    } else {
+                        "Enable closing confirmation"
+                    }
+                }
+                addEventListener("click", {
+                    webApp.toggleClosingConfirmation()
+                    updateText()
+                })
+                updateText()
+            } ?: window.alert("Unable to load body")
+
+            document.body ?.appendElement("p", {})
+
+            webApp.apply {
+                onThemeChanged {
+                    document.body ?.log("Theme changed: ${webApp.themeParams}")
+                }
+                onViewportChanged {
+                    document.body ?.log("Viewport changed: ${it.isStateStable}")
+                }
+                backButton.apply {
+                    onClick {
+                        document.body ?.log("Back button clicked")
+                        hapticFeedback.impactOccurred(
+                            HapticFeedbackStyle.Heavy
+                        )
+                    }
+                    show()
+                }
+                mainButton.apply {
+                    setText("Main button")
+                    onClick {
+                        document.body ?.log("Main button clicked")
+                        hapticFeedback.notificationOccurred(
+                            HapticFeedbackType.Success
+                        )
+                    }
+                    show()
+                }
+                onSettingsButtonClicked {
+                    document.body ?.log("Settings button clicked")
+                }
+            }
+            webApp.ready()
+        }.onFailure {
+            window.alert(it.stackTraceToString())
+        }
+    }
+}

WebApp/src/jsMain/resources/index.html

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="format-detection" content="telephone=no"/>
+        <meta http-equiv="X-UA-Compatible" content="IE=edge"/>
+        <meta name="HandheldFriendly" content="True"/>
+        <meta name="robots" content="noindex,nofollow"/>
+        <meta name="viewport" content="width=device-width, height=device-height, initial-scale=1.0, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no"/>
+        <title>Web App Example</title>
+    </head>
+    <body>
+        <script type="application/javascript" src="https://telegram.org/js/telegram-web-app.js"></script>
+        <script type="application/javascript" src="WebApp.js"></script>
+    </body>
+</html>

WebApp/src/jvmMain/kotlin/WebAppServer.kt

@@ -0,0 +1,122 @@
+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.bot.getMe
+import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
+import dev.inmo.tgbotapi.extensions.api.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.botCommand
+import dev.inmo.tgbotapi.extensions.utils.formatting.buildEntities
+import dev.inmo.tgbotapi.extensions.utils.types.buttons.*
+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.webAppQueryIdField
+import dev.inmo.tgbotapi.types.webapps.WebAppInfo
+import dev.inmo.tgbotapi.utils.PreviewFeature
+import dev.inmo.tgbotapi.utils.TelegramAPIUrlsKeeper
+import io.ktor.http.*
+import io.ktor.server.application.call
+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 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
+ *
+ * Will start the server to share the static (index.html and WebApp.js) on 0.0.0.0:8080
+ */
+@OptIn(PreviewFeature::class)
+suspend fun main(vararg args: String) {
+    val telegramBotAPIUrlsKeeper = TelegramAPIUrlsKeeper(
+        args.first(),
+        testServer = args.any { it == "testServer" }
+    )
+    val bot = telegramBot(telegramBotAPIUrlsKeeper)
+    createKtorServer(
+        "0.0.0.0",
+        8080,
+        additionalEngineEnvironmentConfigurator = {
+            parentCoroutineContext += Dispatchers.IO
+        }
+    ) {
+        routing {
+            static {
+                files(File("WebApp/build/distributions"))
+                default("WebApp/build/distributions/index.html")
+            }
+            post("inline") {
+                val requestBody = call.receiveText()
+                val queryId = call.parameters[webAppQueryIdField] ?: error("$webAppQueryIdField should be presented")
+
+                bot.answer(queryId, InlineQueryResultArticle(queryId, "Result", InputTextMessageContent(requestBody)))
+                call.respond(HttpStatusCode.OK)
+            }
+            post("check") {
+                val requestBody = call.receiveText()
+                val webAppCheckData = Json {  }.decodeFromString(WebAppDataWrapper.serializer(), requestBody)
+
+                val isSafe = telegramBotAPIUrlsKeeper.checkWebAppData(webAppCheckData.data, webAppCheckData.hash)
+
+                call.respond(HttpStatusCode.OK, isSafe.toString())
+            }
+        }
+    }.start(false)
+
+    bot.buildBehaviourWithLongPolling(
+        defaultExceptionsHandler = { it.printStackTrace() }
+    ) {
+        onCommand("reply_markup") {
+            reply(
+                it,
+                "Button",
+                replyMarkup = replyKeyboard(resizeKeyboard = true, oneTimeKeyboard = true) {
+                    row {
+                        webAppButton("Open WebApp", WebAppInfo(args[1]))
+                    }
+                }
+
+            )
+        }
+        onCommand("inline") {
+            reply(
+                it,
+                "Button",
+                replyMarkup = inlineKeyboard {
+                    row {
+                        webAppButton("Open WebApp", WebAppInfo(args[1]))
+                    }
+                }
+
+            )
+        }
+        onUnhandledCommand {
+            reply(
+                it,
+                buildEntities {
+                    +"Use " + botCommand("inline") + " to get inline web app button\n"
+                    +"Use " + botCommand("reply_markup") + " to get reply markup web app button\n"
+                }
+            )
+        }
+        setMyCommands(
+            BotCommand("reply_markup", "Use to get reply markup keyboard with web app trigger"),
+            BotCommand("inline", "Use to get inline keyboard with web app trigger"),
+        )
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
+            println(it)
+        }
+        println(getMe())
+    }.join()
+}

build.gradle

@@ -1,5 +1,26 @@
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+        classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
+    }
+}
+
 allprojects {
     repositories {
         mavenLocal()
+        mavenCentral()
+        if (project.hasProperty("GITHUB_USER") && project.hasProperty("GITHUB_TOKEN")) {
+            maven {
+                url "https://maven.pkg.github.com/InsanusMokrassar/TelegramBotAPI"
+                credentials {
+                    username = project.getProperty("GITHUB_USER")
+                    password = project.getProperty("GITHUB_TOKEN")
+                }
+            }
+        }
     }
-}
+}

gradle.properties

@@ -1,5 +1,11 @@
 kotlin.code.style=official
 org.gradle.parallel=true
+# Due to parallel compilation project require next amount of memory on full build
+org.gradle.jvmargs=-Xmx768m
 
-kotlin_version=1.4.10
-telegram_bot_api_version=0.28.5
+
+kotlin_version=1.7.10
+telegram_bot_api_version=3.1.1
+micro_utils_version=0.12.1
+serialization_version=1.4.0-RC
+ktor_version=2.1.0

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

settings.gradle

@@ -1,7 +1,24 @@
-include ":ForwarderBot"
+include ":ForwardInfoSenderBot"
+
 include ":RandomFileSenderBot"
+
 include ":HelloBot"
+
 include ":GetMeBot"
+
 include ":FilesLoaderBot"
+
 include ":ResenderBot:ResenderBotLib"
 include ":ResenderBot:jvm_launcher"
+
+include ":KeyboardsBot:KeyboardsBotLib"
+include ":KeyboardsBot:jvm_launcher"
+
+include ":StickerInfoBot:StickerInfoBotLib"
+include ":StickerInfoBot:jvm_launcher"
+
+include ":SlotMachineDetectorBot"
+
+include ":WebApp"
+
+include ":FSMBot"