Update dependency org.jetbrains.kotlin.jvm to v2.4.21

Update dependency dev.inmo:tgbotapi to v24.0.2

.github/workflows/build.yml

@@ -8,9 +8,9 @@ jobs:
 
     steps:
       - uses: actions/checkout@v2
-      - name: Set up JDK 1.8
+      - name: Set up JDK 17
         uses: actions/setup-java@v1
         with:
-          java-version: 1.8
+          java-version: 17
       - name: Build with Gradle
         run: ./gradlew build

.gitignore

@@ -1,4 +1,5 @@
 .idea
+.kotlin
 out/*
 *.iml
 target
@@ -9,5 +10,6 @@ settings.xml
 build/
 out/
 
-local.properties
+local.*
+local.*/
 secret.gradle

Dockerfile

@@ -0,0 +1,8 @@
+FROM adoptopenjdk/openjdk11
+
+USER 1000
+
+ENTRYPOINT ["/telegram_bot/bin/telegram_bot", "/telegram_bot/local.config.json"]
+
+ADD ./build/distributions/telegram_bot.tar /
+ADD ./local.config.json /telegram_bot/

Makefile

@@ -0,0 +1,19 @@
+#!make
+
+.ONESHELL:
+.PHONY:
+
+clean:
+	./gradlew clean
+
+build:
+	./gradlew build
+
+start:
+	./gradlew run
+
+startCompose:
+	docker-compose build && docker-compose up
+
+buildAndStartCompose:
+	make clean build startCompose

README.md

@@ -9,19 +9,72 @@ it was described [here](https://github.com/InsanusMokrassar/TelegramBotAPI#ok-wh
 
 ## Default
 
-Since you have used this repo as a template you can simply run command `./gradlew run --args="BOT_TOKEN"` (of course,
+Since you have used this repo as a template you can copy file `example.config.json` as `local.config.json`, put there your bot token and simply run command `./gradlew run --args="local.config.json"`. As an output you will get your bot information like:
-replace here `BOT_TOKEN` with your telegram bot token like `1234567890:ABCDEFGHIJKLM_OPqrstuvwxyz012345678`). As an
-output you will get your bot information like:
 
 ```bash
 ExtendedBot(id=ChatId(chatId=1234567890), username=Username(username=@username_of_your_bot), firstName=Name of bot, lastName=, canJoinGroups=(some boolean), canReadAllGroupMessages=(some boolean), supportsInlineQueries=(some boolean))
 ```
 
+### Docker
+
+In this template there is template-like [docker-compose](docker-compose.yml) and [docker](Dockerfile) files. Besides,
+there is [Makefile](Makefile) and you may use something like `make buildAndStartCompose` to start your bot.
+
+It is important to replace `"TOKEN"` in [Dockerfile](Dockerfile) or remove and add some config as a volume.
+
+### Config
+
+But you may set up several things for your bot. You should start with adding client object:
+
+```json
+{
+  "token": "your bot token",
+  "client": {
+    "connectionTimeoutMillis": 10000,
+    "requestTimeoutMillis": 10000,
+    "responseTimeoutMillis": 10000,
+    "proxy": {
+      "hostname": "127.0.0.1",
+      "port": 1080,
+      "type": "socks",
+      "username": "username",
+      "password": "password"
+    }
+  }
+}
+```
+
+__Required__ fields:
+
+* `token`
+* `client/proxy/hostname` (if you pass `client` and `proxy` fields) - hostname of proxy server
+* `client/proxy/password` - password for authentication on proxy server, required if `client/proxy/type` is `socks` and `client/proxy/username` passed
+
+__Optional__ fields:
+
+* `client` - object with client configs
+* `client/connectionTimeoutMillis` - timeout for connection to the server
+* `client/requestTimeoutMillis` - timeout for request complete (when request taken on server)
+* `client/responseTimeoutMillis` - timeout for getting a response after request taken on server
+* `client/proxy` - proxy settings
+* `client/proxy/port` - port of proxy server
+* `client/proxy/type` - type of proxy server (can be `socks` or `http`)
+* `client/proxy/username` - username for authentication on proxy server
+* `client/proxy/password` - password for authentication on proxy server
+
+Basically, your config looks like an object with token:
+
+```json
+{
+  "token": "your bot token"
+}
+```
+
 ## What next?
 
 There are several ways to continue:
 
-* [Tutorials](https://bookstack.inmo.dev/books/telegrambotapi)
+* [Tutorials](https://docs.inmo.dev/tgbotapi/index.html)
 * [Github readme](https://github.com/InsanusMokrassar/TelegramBotAPI)
 
 In other words, this template (and [TelegramBotAPI library](https://github.com/InsanusMokrassar/TelegramBotAPI)) does

build.gradle

@@ -1,31 +1,37 @@
 buildscript {
     repositories {
-        jcenter()
+        mavenCentral()
     }
 
     dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+        classpath libs.kotlin.gradle.plugin
-        classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
+        classpath libs.kotlin.serialization.plugin
     }
 }
 
 plugins {
-    id 'org.jetbrains.kotlin.jvm' version "$kotlin_version"
+    alias libs.plugins.kotlin.jvm
-    id "org.jetbrains.kotlin.plugin.serialization" version "$kotlin_version"
+    alias libs.plugins.kotlin.serialization
     id 'application'
 }
 
 repositories {
-    jcenter()
     mavenCentral()
+    maven { url "https://git.inmo.dev/api/packages/InsanusMokrassar/maven" }
 }
 
 dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    implementation libs.kotlin
 
-    implementation "dev.inmo:tgbotapi:$tgbotapi_version"
+    implementation libs.tgbotapi
+    implementation libs.ktor.client.okhttp
 }
 
 application {
-    mainClassName = 'telegram_bot.AppKt'
+    mainClassName = 'AppKt'
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
 }

docker-compose.yml

@@ -0,0 +1,6 @@
+version: "3.4"
+
+services:
+  server:
+    build: .
+    restart: unless-stopped

example.config.json

@@ -0,0 +1,15 @@
+{
+  "token": "your bot token",
+  "client": {
+    "connectionTimeoutMillis": 10000,
+    "requestTimeoutMillis": 10000,
+    "responseTimeoutMillis": 10000,
+    "proxy": {
+      "hostname": "127.0.0.1",
+      "port": 1080,
+      "type": "socks",
+      "username": "username",
+      "password": "password"
+    }
+  }
+}

gradle.properties

@@ -3,6 +3,3 @@ kotlin.code.style=official
 org.gradle.parallel=true
 kotlin.js.generate.externals=true
 kotlin.incremental=true
-
-kotlin_version=1.4.21
-tgbotapi_version=0.32.0

gradle/libs.versions.toml

@@ -0,0 +1,22 @@
+[versions]
+
+kotlin = "2.4.21"
+tgbotapi = "33.1.0"
+ktor = "3.4.2"
+
+[libraries]
+
+kotlin = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kotlin" }
+tgbotapi = { module = "dev.inmo:tgbotapi", version.ref = "tgbotapi" }
+
+ktor-client-okhttp = { module = "io.ktor:ktor-client-okhttp", version.ref = "ktor" }
+
+# Libs for classpath
+kotlin-gradle-plugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
+kotlin-serialization-plugin = { module = "org.jetbrains.kotlin:kotlin-serialization", version.ref = "kotlin" }
+
+[plugins]
+
+kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
+

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.8-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.4-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

renovate.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended"
+  ]
+}

src/main/kotlin/App.kt

@@ -0,0 +1,49 @@
+import config.Config
+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.buildBehaviourWithLongPolling
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
+import io.ktor.client.*
+import io.ktor.client.engine.okhttp.*
+import java.io.File
+import kotlinx.coroutines.*
+import kotlinx.serialization.json.Json
+
+/**
+ * This method by default expects one argument in [args] field: telegram bot configuration
+ */
+suspend fun main(args: Array<String>) {
+    // create json to decode config
+    val json = Json { ignoreUnknownKeys = true }
+    // decode config
+    val config: Config = json.decodeFromString(Config.serializer(), File(args.first()).readText())
+    // that is your bot
+    val bot = telegramBot(config.token) {
+        client = HttpClient(OkHttp) {
+            config.client ?.apply {
+                // setting up telegram bot client
+                setupConfig()
+            }
+        }
+    }
+
+    // that is kotlin coroutine scope which will be used in requests and parallel works under the hood
+    val scope = CoroutineScope(Dispatchers.Default)
+
+    // here should be main logic of your bot
+    bot.buildBehaviourWithLongPolling(scope) {
+        // in this lambda you will be able to call methods without "bot." prefix
+        val me = getMe()
+
+        // this method will create point to react on each /start command
+        onCommand("start", requireOnlyCommandInMessage = true) {
+            // simply reply :)
+            reply(it, "Hello, I am ${me.firstName}")
+        }
+
+        // That will be called on the end of bot initiation. After that println will be started long polling and bot will
+        // react on your commands
+        println(me)
+    }.join()
+}

src/main/kotlin/config/Config.kt

@@ -0,0 +1,9 @@
+package config
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class Config(
+    val token: String,
+    val client: HttpClientConfig? = null
+)

src/main/kotlin/config/HttpClientConfig.kt

@@ -0,0 +1,90 @@
+package config
+
+import dev.inmo.tgbotapi.types.MilliSeconds
+import io.ktor.client.HttpClientConfig
+import io.ktor.client.engine.okhttp.*
+import io.ktor.client.plugins.*
+import io.ktor.client.request.*
+import io.ktor.http.*
+import kotlinx.serialization.Serializable
+import java.net.*
+import java.util.*
+import java.util.concurrent.TimeUnit
+
+@Serializable
+data class HttpClientConfig(
+    val connectionTimeoutMillis: MilliSeconds? = null,
+    val requestTimeoutMillis: MilliSeconds? = null,
+    val responseTimeoutMillis: MilliSeconds? = null,
+    val proxy: ProxyConfig? = null
+) {
+    @Serializable
+    data class ProxyConfig(
+        val hostname: String,
+        val type: ProxyType = ProxyType.socks,
+        val port: Int = type.defaultPort,
+        val username: String? = null,
+        val password: String? = null
+    ) {
+        @Serializable
+        enum class ProxyType(val defaultPort: Int, val proxyType: Proxy.Type) {
+            socks(1080, Proxy.Type.SOCKS),
+            http(3128, Proxy.Type.HTTP),
+        }
+
+        val socketAddress
+            get() = InetSocketAddress(hostname, port)
+    }
+
+    fun HttpClientConfig<OkHttpConfig>.setupConfig() {
+        // setting up telegram bot client
+        engine {
+            // Start setup bot client engine configuration
+            config {
+                // setting up connection timeout millis
+                connectionTimeoutMillis ?.let { connectTimeout(it, TimeUnit.MILLISECONDS) }
+                // setting up write timeout millis
+                requestTimeoutMillis ?.let { writeTimeout(it, TimeUnit.MILLISECONDS) }
+                // setting up read timeout millis
+                responseTimeoutMillis ?.let { readTimeout(it, TimeUnit.MILLISECONDS) }
+
+                // Start setup bot client engine proxy
+                this@HttpClientConfig.proxy ?.let { proxyConfig ->
+                    proxy(
+                        Proxy(
+                            proxyConfig.type.proxyType,
+                            proxyConfig.socketAddress
+                        )
+                    )
+
+                    proxyConfig.username ?.let { username ->
+                        when (proxyConfig.type) {
+                            config.HttpClientConfig.ProxyConfig.ProxyType.socks -> {
+                                val passwordAuthentication = PasswordAuthentication(
+                                    username,
+                                    proxyConfig.password ?.toCharArray() ?: error("For Socks proxy you should use both username and password or do not use authentication at all")
+                                )
+                                Authenticator.setDefault(object : Authenticator() {
+                                    override fun getPasswordAuthentication(): PasswordAuthentication? {
+                                        return if (requestingHost.lowercase() == proxyConfig.hostname.lowercase()) {
+                                            passwordAuthentication
+                                        } else {
+                                            null
+                                        }
+                                    }
+                                })
+                            }
+                            config.HttpClientConfig.ProxyConfig.ProxyType.http -> {
+                                val passwordSuffix = proxyConfig.password ?.let { ":$it" }
+                                val credentials = Base64.getEncoder().encodeToString("${username}${passwordSuffix}".toByteArray())
+                                this@setupConfig.defaultRequest {
+                                    header(HttpHeaders.ProxyAuthorization, "Basic $credentials")
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

src/main/kotlin/telegram_bot/App.kt

@@ -1,33 +0,0 @@
-package telegram_bot
-
-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.buildBehaviour
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
-import kotlinx.coroutines.*
-
-/**
- * This method by default expects one argument in [args] field: telegram bot token
- */
-suspend fun main(args: Array<String>) {
-    // that is your bot
-    val bot = telegramBot(args.first())
-
-    // that is kotlin coroutine scope which will be used in requests and parallel works under the hood
-    val scope = CoroutineScope(Dispatchers.Default)
-
-    // here should be main logic of your bot
-    bot.buildBehaviour(scope) {
-        // in this lambda you will be able to call methods without "bot." prefix
-        val me = getMe()
-
-        // this method will create point to react on each /start command
-        onCommand("/start", requireOnlyCommandInMessage = true) {
-            // simply reply :)
-            reply(it, "Hello, I am ${me.firstName}")
-        }
-    }
-
-    scope.coroutineContext.job.join()
-}