Update ktor monorepo to v3.3.3

29.0.0

BusinessConnectionsBot/src/main/kotlin/BusinessConnectionsBot.kt

@@ -34,6 +34,7 @@ import dev.inmo.tgbotapi.extensions.utils.ifBusinessContentMessage
 import dev.inmo.tgbotapi.extensions.utils.textContentOrNull
 import dev.inmo.tgbotapi.extensions.utils.types.buttons.dataButton
 import dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard
+import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.flushAccumulatedUpdates
 import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
 import dev.inmo.tgbotapi.requests.abstracts.multipartFile
 import dev.inmo.tgbotapi.requests.business_connection.InputProfilePhoto
@@ -84,6 +85,7 @@ suspend fun main(args: Array<String>) {
     telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO)) {
         val me = getMe()
         println(me)
+        flushAccumulatedUpdates()
 
         onBusinessConnectionEnabled {
             businessConnectionsChatsMutex.withLock {
@@ -471,5 +473,15 @@ suspend fun main(args: Array<String>) {
                 }
             }
         }
+
+        // Will work when some premium user sending to some other user checklist
+        onChecklistContent {
+            execute(
+                it.content.createResend(
+                    it.chat.id,
+                    businessConnectionId = it.chat.id.businessConnectionId ?: chatsBusinessConnections[it.chat.id] ?: return@onChecklistContent
+                )
+            )
+        }
     }.second.join()
 }

ChecklistsBot/build.gradle

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

ChecklistsBot/src/main/kotlin/ChecklistsBot.kt

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

CustomBot/src/main/kotlin/CustomBot.kt

@@ -4,10 +4,13 @@ import dev.inmo.kslog.common.defaultMessageFormatter
 import dev.inmo.kslog.common.setDefaultKSLog
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
+import dev.inmo.tgbotapi.extensions.api.bot.getMyStarBalance
 import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
+import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContextData
 import dev.inmo.tgbotapi.extensions.behaviour_builder.buildSubcontextInitialAction
 import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChannelDirectMessagesConfigurationChanged
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
 import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
 import dev.inmo.tgbotapi.types.update.abstracts.Update
@@ -79,6 +82,17 @@ suspend fun main(vararg args: String) {
             println(data.commonMessage)
         }
 
+        onCommand("getMyStarBalance") {
+            reply(
+                to = it,
+                text = getMyStarBalance().toString()
+            )
+        }
+
+        onChannelDirectMessagesConfigurationChanged {
+            println(it.chatEvent)
+        }
+
         allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
             println(it)
         }

FSMBot/src/main/kotlin/SimpleFSMBot.kt

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

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

@@ -1,3 +1,6 @@
+import dev.inmo.kslog.common.KSLog
+import dev.inmo.kslog.common.defaultMessageFormatter
+import dev.inmo.kslog.common.filter.filtered
 import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.send.withTypingAction
@@ -10,7 +13,9 @@ import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
 import dev.inmo.tgbotapi.types.ReplyParameters
 import dev.inmo.tgbotapi.types.message.abstracts.BusinessContentMessage
 import dev.inmo.tgbotapi.types.message.content.TextContent
+import dev.inmo.tgbotapi.utils.DefaultKTgBotAPIKSLog
 import dev.inmo.tgbotapi.utils.extensions.threadIdOrNull
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.currentCoroutineContext
@@ -19,7 +24,10 @@ suspend fun activateResenderBot(
     token: String,
     print: (Any) -> Unit
 ) {
-    telegramBotWithBehaviourAndLongPolling(token, scope = CoroutineScope(currentCoroutineContext() + SupervisorJob())) {
+    telegramBotWithBehaviourAndLongPolling(
+        token,
+        scope = CoroutineScope(currentCoroutineContext() + SupervisorJob()),
+    ) {
         onContentMessage(
             subcontextUpdatesFilter = MessageFilterByChat,
             initialFilter = { it !is BusinessContentMessage<*> || !it.sentByBusinessConnectionOwner }

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

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

RightsChangerBot/build.gradle

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

StarTransactionsBot/README.md

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

SuggestedPosts/README.md

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

SuggestedPosts/build.gradle

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

SuggestedPosts/src/main/kotlin/SuggestedPostsBot.kt

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

WebApp/src/jsMain/kotlin/main.kt

@@ -163,6 +163,34 @@ fun main() {
             Text("Answer in chat button")
         }
 
+        H3 { Text("Hide keyboard") }
+        val hideCountdown = remember { mutableStateOf<Int?>(null) }
+        Button({
+            onClick {
+                hideCountdown.value = 5
+            }
+        }) {
+            if (hideCountdown.value == null) {
+                Text("Hide")
+            } else {
+                Text("Hide in ${hideCountdown.value} seconds")
+            }
+        }
+        LaunchedEffect(hideCountdown.value) {
+            val value = hideCountdown.value
+            when {
+                value == null -> return@LaunchedEffect
+                value > 0 -> {
+                    delay(1000)
+                    hideCountdown.value = hideCountdown.value ?.minus(1)
+                }
+                else -> {
+                    webApp.hideKeyboard()
+                    hideCountdown.value = null
+                }
+            }
+        }
+
         P()
         H3 { Text("User info") }
         Text("Allow to write in private messages: ${webApp.initDataUnsafe.user ?.allowsWriteToPM ?: "User unavailable"}")

gradle.properties

@@ -5,9 +5,9 @@ org.gradle.jvmargs=-Xmx3148m
 kotlin.daemon.jvmargs=-Xmx3g -Xms500m
 
 
-kotlin_version=2.1.20
+kotlin_version=2.2.10
-telegram_bot_api_version=25.0.0
+telegram_bot_api_version=29.0.0
-micro_utils_version=0.25.3
+micro_utils_version=0.26.3
-serialization_version=1.8.0
+serialization_version=1.9.0
-ktor_version=3.1.1
+ktor_version=3.3.3
-compose_version=1.7.3
+compose_version=1.8.2

gradle/wrapper/gradle-wrapper.properties

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

settings.gradle

@@ -59,3 +59,7 @@ include ":CustomBot"
 include ":MemberUpdatedWatcherBot"
 
 include ":WebHooks"
+
+include ":SuggestedPosts"
+
+include ":ChecklistsBot"