update template

src/main/kotlin/App.kt

@@ -1,8 +1,11 @@
+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
@@ -16,7 +19,14 @@ suspend fun main(args: Array<String>) {
     // decode config
     val config: Config = json.decodeFromString(Config.serializer(), File(args.first()).readText())
     // that is your bot
-    val bot = telegramBot(config.token)
+    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)

src/main/kotlin/Config.kt

@@ -1,6 +0,0 @@
-import kotlinx.serialization.Serializable
-
-@Serializable
-data class Config(
-    val token: String
-)

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,89 @@
+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.Authenticator
+import java.net.InetSocketAddress
+import java.net.PasswordAuthentication
+import java.net.Proxy
+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 passwordAuthentication
+                                    }
+                                })
+                            }
+                            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")
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}