Expected behavior Commands that the user sends are received reliably in the telegram bot

Actual behavior After about 1 hour of run time of my telegram bot newly sent commands dont "arrive" in the application. In the time from start up until about 1 hour the commands "arrive" reliably. After a restart of my telegram bot the stuck commands are processed directly at startup. Also, the bot sends a message like every 10 seconds, which works fine. I noticed this behaviour for about 5 days now and I did not update anything.

To Reproduce Hard to reproduce. Currently I am running the application directly with IntelliJ.

Screenshots/Traceback No exceptions occur / are visible. Is there a way to see a log of my telegram bot from the Telegram's perspective?

According to telegram bot api for sendVoice, it also accepts 3 parameters not presented in current api: caption, parseMode and captionEntities.

P.S> not sure how I suppose to write tests for it, although I tested it manually.

Expected behavior editMessageMedia edits the media of a message. The user sees this change immediately.

Actual behavior Nothing happens.

To Reproduce Call the method linked above and provide a bot-unique file ID.

Screenshots/Traceback

bot.editMessageMedia(
            -447268747,
            4870,
            media = InputMediaPhoto(TelegramFile.ByFileId(
                "AgACAgIAAxkBAAITB2EL_xbqiVhVbSBPTKpw2HnE3P0eAAKItTEbXEJhSJ7zGYnW9n3UAQADAgADbQADIAQ")),
            replyMarkup = null)

Possible solutions Perhaps this is related to the JSON serialisation of the TelegramFile.ByFileId object? [reference]

Additional context Using the same parameters in a direct POST request to the API endpoint, the message gets edited correctly:

https://api.telegram.org/bot<token>/editMessageMedia?media={%22type%22:%22photo%22,%22media%22:%22AgACAgIAAxkBAAITB2EL_xbqiVhVbSBPTKpw2HnE3P0eAAKItTEbXEJhSJ7zGYnW9n3UAQADAgADbQADIAQ%22}&message_id=4870&chat_id=-447268747

This validates message ID, chat ID, and file ID.

This is finally ready.

I have migrated all the handlers available in the library to now use functions with receivers. In this way it'll be possible to access to all the data correspondent to the updates in the scope of the handler function without the need of explicitly indicating these data parameters in the handler lambda function.

There is one commit per migrated handler (all the commits that reference the issue https://github.com/kotlin-telegram-bot/kotlin-telegram-bot/issues/96)

Also, there are some clean up commits:

• https://github.com/kotlin-telegram-bot/kotlin-telegram-bot/pull/103/commits/e1978f8e0a343323878028a6bea516a582311fb2
• https://github.com/kotlin-telegram-bot/kotlin-telegram-bot/pull/103/commits/8d7d45df9b2760b8de799f291efe3cf20db1b069
• https://github.com/kotlin-telegram-bot/kotlin-telegram-bot/pull/103/commits/c9a0b5f6e5ec34db130863ba620c11072270b702

If these changes look good to you, we can finally proceed with this issue https://github.com/kotlin-telegram-bot/kotlin-telegram-bot/issues/93

Expected behavior there is a message block inside the callbackQuery(A). inside that message block we ask yes or no question with InlineKeyboardButton. for example, if the user chooses yes, it will go to callbackQuery(B). but if chooses no, callbackQuery(A) will be called again.

Actual behavior The problem starts when the user chooses no for the first time. after going throw all again, if he chooses no again, InlineKeyboardButton will popup twice!

To Reproduce

callbackQuery("A") {
    val chatId = callbackQuery.message?.chat?.id ?: return@callbackQuery
    bot.sendMessage(
        chatId = chatId,
        text = """some input""",
    )

    message {
        val inlineKeyboardMarkup = InlineKeyboardMarkup.create(
            listOf(
                InlineKeyboardButton.CallbackData(text = "no", callbackData = "A"),
                InlineKeyboardButton.CallbackData(text = "yes", callbackData = "B"),
            ),
        )
        bot.sendMessage(
            chatId = message.chat.id,
            text = """
            your choice
        """.trimIndent(),
            replyMarkup = inlineKeyboardMarkup
        )
    }
}

Additional context I think the possibility of my code being wrong is high but there is no place to ask my question, so I asked here so maybe, maybe, there is a bug.

Changed HandlersDsl.kt to account for changes in addHandler

You can now add handlers in dispatcher specifying their names, every handler is added in a mutableMap with its name as a key. If no name is specified then it is either defaulted to null or to main parameter of handler

Since the last version at least 2 breaking changes have been introduced: #82 and #91 (not merged at the moment but approved).

Maybe it's time to create a major version with big changes and release all breaking changes at the same time.

I opened this issue to plan the next release and to ask if there are any other changes you have always wanted to introduce but were afraid because of breaking too many things.

Hello. I modified vjgarciag96 branch handlers-to-functions-with-receiver. Handlers to functions with receiver #96 can be implemented a little easier, without a proxy. Please take a look. Don't kick me too hard, this is my first experience on github and writing in Kotlin.

P.S.: I didn't even need to add HandlerEnvironment, but I need it for the next PR(chain of steps). Thanks.

Hello everyone! I'm a newcomer for Telegram bot programming and I'm not really sure if this is a bug or it's me doing something wrong. If that's the case forgive me!

I'm trying to create a bot which simply returns data from a json file, filtering and manipulating it. Each json has a tag called "level", so I wrote a "search by level" callback query. Once is fired, this callback sends a message to ask the user to input the level (from 0 to 9). Then the bot simply reads the json and filters the output to send as a message.

The problem is that it sends duplicates while the callback is fired more than once. If you fire it 2 times, it will send 2 messages and the third time it will send 3 messages, and so on.

Here's the code:

 val holder = deserializeSpells("/home/nicola/Desktop/formattedFile.json")
 val bot = bot {
        dispatch {
            command("start") {
                bot.sendMessage(ChatId.fromId(update.message!!.chat.id),"<b><i>Benvenuto in WizardBook!</i></b>", parseMode = ParseMode.HTML)
                bot.sendMessage(ChatId.fromId(update.message!!.chat.id),"Ti aiuterò a trovare gli incantesimi!")
                val replyMarkup = InlineKeyboardMarkup.create(
                    listOf(
                        InlineKeyboardButton.CallbackData("Cerca per livello","bylevel"),
                        InlineKeyboardButton.CallbackData("Cerca per classe","byclass")),
                    listOf(
                        InlineKeyboardButton.CallbackData("Cerca per scuola","byschool"),
                        InlineKeyboardButton.CallbackData("Cerca per nome (o un pezzo)","byname")),
                    listOf(InlineKeyboardButton.CallbackData("Cerca per nome (preciso)","byreference")),
                    listOf(InlineKeyboardButton.CallbackData("La magia del giorno!","byday")),
                    listOf(InlineKeyboardButton.CallbackData("Contatti","bycontacts"))
                )
                bot.sendMessage(ChatId.fromId(message.chat.id),"Scegli il metodo di ricerca", replyMarkup = replyMarkup)
            }

            callbackQuery ("bylevel") {
                val chatId = update.callbackQuery?.message!!.chat.id
                bot.sendMessage(ChatId.fromId(chatId),"Che livello stai cercando? <u>(Da 0 a 9)</u>", parseMode = ParseMode.HTML)
                text {
                    var out :String = ""
                    holder.forEach {
                        if (it.level == text) out+= "\n${it.name}\n<i><u>Lvl. ${it.level} Classi ${it.combat}</u></i>"
                    }
                    bot.sendMessage(ChatId.fromId(chatId),out, parseMode = ParseMode.HTML)
                }
            }
        }
    }
    bot.startPolling()

Maybe it's me not understanding how to properly handle updates? Thanks a lot!

Adds Filters, see sample about how it works. It's more like a proposal, there might be better ways to implement this and use cases I forgot to consider.

A few things to note:

• and doesn't take precedence over or, ~maybe we should wait for https://github.com/JetBrains/kotlin/pull/1769 instead of this~
• an other option is to use + and *
• some builtin filters could be implemented later, like message contains url, etc.

As discussed in https://github.com/kotlin-telegram-bot/kotlin-telegram-bot/issues/128, here I refactored all chat_id parameters to support numeric ids as well as channel usernames.

Is your feature request related to a problem? Please describe.

Describe the solution you'd like

Describe alternatives you've considered

Implementation ideas

Additional context

Expected behavior Message class contains webAppData field

Actual behavior Message class doesn't contain webAppData field

To Reproduce Create a web app and try to send data back to the bot via sendData js method

Trying to print Log:

val bot = bot {
        ...
        logLevel = LogLevel.All()
    }

But:

Exception in thread "pool-1-thread-2" java.lang.NoSuchMethodError: 'void okhttp3.internal.platform.Platform.log(int, java.lang.String, java.lang.Throwable)'
	at okhttp3.logging.HttpLoggingInterceptor$Logger$1.log(HttpLoggingInterceptor.java:111)
	at okhttp3.logging.HttpLoggingInterceptor.intercept(HttpLoggingInterceptor.java:159)
	at okhttp3.internal.http.RealInterceptorChain.proceed(RealInterceptorChain.kt:109)
	at okhttp3.internal.connection.RealCall.getResponseWithInterceptorChain$okhttp(RealCall.kt:201)
	at okhttp3.internal.connection.RealCall.execute(RealCall.kt:154)
	at retrofit2.OkHttpCall.execute(OkHttpCall.java:204)
	at com.github.kotlintelegrambot.network.ApiRequestSender.send(ApiRequestSender.kt:7)
	at com.github.kotlintelegrambot.network.ApiClient.runApiOperation(ApiClient.kt:1329)
	at com.github.kotlintelegrambot.network.ApiClient.getUpdates(ApiClient.kt:120)
	at com.github.kotlintelegrambot.updater.Updater$startPolling$1.invoke(Updater.kt:21)
	at com.github.kotlintelegrambot.updater.Updater$startPolling$1.invoke(Updater.kt:20)
	at com.github.kotlintelegrambot.updater.ExecutorLooper.runLoop(Looper.kt:28)
	at com.github.kotlintelegrambot.updater.ExecutorLooper.loop$lambda-0(Looper.kt:23)
	at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1136)
	at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:635)
	at java.base/java.lang.Thread.run(Thread.java:833)

Then I found that kotlin-telegram-bot depends on okhttp 3.14.9

And ktor depends on 4.9.3....

Expected behavior New handlers are not added with addhandler() if they already exist in the same scope

Actual behavior New handlers with the same values are added indefinitely

To Reproduce

Dispatcher

import com.github.kotlintelegrambot.bot
import com.github.kotlintelegrambot.dispatch
import com.github.kotlintelegrambot.logging.LogLevel

fun main() {
    val bot = bot {
        token = "Your Token"
        timeout = 30
        logLevel = LogLevel.None
        dispatch {          
            command("command1") {
            }
            command("command1") {
            }   
    }
    bot.startPolling()
}

Dispatcher.addHandler()

fun addHandler(handler: Handler) {
        commandHandlers.forEach {
            if (it == handler) {
                println("Handler exists already")
                return
            }
        }
        commandHandlers.add(handler)
        println("Added new handler $handler")
    }

Screenshots/Traceback

As you can see here handlers are compared by their hashes, that always differ, and not by their parameters Thus a new handler is always added regardless of whether the same is already present in commands

Possible solutions Override an equals method for each Handler in telegram/src/main/kotlin/com/github/kotlintelegrambot/dispatcher/handlers

Additional context I have posted an issue about Dispatcher.removeHandler() here, If you solve the latter, the former can be skipped https://github.com/kotlin-telegram-bot/kotlin-telegram-bot/issues/262