Add sendEphemeralMessage.callback_query_id.

5 files changed, 38 insertions, 21 deletions

diff --git a/td/generate/scheme/td_api.tl b/td/generate/scheme/td_api.tl
index 1fd667443..df3e3a051 100644
--- a/td/generate/scheme/td_api.tl
+++ b/td/generate/scheme/td_api.tl
@@ -12115,6 +12115,7 @@ resendMessages chat_id:int53 message_ids:vector<int53> quote:inputTextQuote paid
 //@chat_id Target chat
 //@topic_id Topic in which the message will be sent; pass null if none
 //@receiver_user_id Identifier of the user who will receive the message
+//@callback_query_id Identifier of the callback query which triggered the message; for bots only
 //@reply_to Information about the message to be replied; pass null if none. The message can be an incoming ephemeral message
 //@sending_id Non-persistent identifier, which will be returned back in messageSendingStatePending object and can be used to match sent messages and corresponding updateNewMessage updates
 //@only_preview Pass true to get a fake message instead of actually sending them
@@ -12122,7 +12123,7 @@ resendMessages chat_id:int53 message_ids:vector<int53> quote:inputTextQuote paid
 //@input_message_content The content of the message to be sent. Must be one of the following types: inputMessageText, inputMessageAnimation,
 //-inputMessageAudio, inputMessageDocument, inputMessagePhoto, inputMessageSticker, inputMessageVideo, inputMessageVideoNote, inputMessageVoiceNote,
 //-inputMessageLocation, inputMessageVenue, inputMessageContact
-sendEphemeralMessage chat_id:int53 topic_id:MessageTopic receiver_user_id:int53 reply_to:InputMessageReplyTo sending_id:int32 only_preview:Bool reply_markup:ReplyMarkup input_message_content:InputMessageContent = Message;
+sendEphemeralMessage chat_id:int53 topic_id:MessageTopic receiver_user_id:int53 callback_query_id:int64 reply_to:InputMessageReplyTo sending_id:int32 only_preview:Bool reply_markup:ReplyMarkup input_message_content:InputMessageContent = Message;
 
 //@description Adds a local message to a chat. The message is persistent across application restarts only if the message database is used. Returns the added message
 //@chat_id Target chat; channel direct messages chats aren't supported
diff --git a/td/telegram/MessagesManager.cpp b/td/telegram/MessagesManager.cpp
index 13d08374a..faf4f6f9a 100644
--- a/td/telegram/MessagesManager.cpp
+++ b/td/telegram/MessagesManager.cpp
@@ -1530,7 +1530,7 @@ class SendMediaQuery final : public Td::ResultHandler {
  public:
   void send(vector<FileUploadId> file_upload_ids, vector<FileUploadId> thumbnail_file_upload_ids,
             vector<FileId> cover_file_ids, int32 flags, DialogId dialog_id,
-            tl_object_ptr<telegram_api::InputPeer> as_input_peer, UserId receiver_user_id,
+            tl_object_ptr<telegram_api::InputPeer> as_input_peer, UserId receiver_user_id, int64 send_callback_query_id,
             const MessageInputReplyTo &input_reply_to, const MessageTopic &message_topic, int32 schedule_date,
             int32 schedule_repeat_period, MessageEffectId effect_id, int64 paid_message_star_count,
             const SuggestedPost *suggested_post, const unique_ptr<ReplyMarkup> &reply_markup, const FormattedText *text,
@@ -1576,12 +1576,15 @@ class SendMediaQuery final : public Td::ResultHandler {
       if (input_reply_markup != nullptr) {
         flags |= telegram_api::ephemeral_sendMessage::REPLY_MARKUP_MASK;
       }
+      if (send_callback_query_id != 0) {
+        flags |= telegram_api::ephemeral_sendMessage::QUERY_ID_MASK;
+      }
 
       auto query = G()->net_query_creator().create(
-          telegram_api::ephemeral_sendMessage(flags, std::move(input_peer), r_input_user.move_as_ok(), 0,
-                                              text == nullptr ? string() : text->text, std::move(entities),
-                                              std::move(input_media.media_), std::move(input_reply_markup),
-                                              std::move(input_media.rich_message_), random_id, std::move(reply_to)),
+          telegram_api::ephemeral_sendMessage(
+              flags, std::move(input_peer), r_input_user.move_as_ok(), send_callback_query_id,
+              text == nullptr ? string() : text->text, std::move(entities), std::move(input_media.media_),
+              std::move(input_reply_markup), std::move(input_media.rich_message_), random_id, std::move(reply_to)),
           {{dialog_id, MessageContentType::Text},
            {dialog_id, is_copy ? MessageContentType::Photo : MessageContentType::Text}});
       *send_query_ref = query.get_weak();
@@ -2374,6 +2377,7 @@ void MessagesManager::Message::store(StorerT &storer) const {
   bool has_guest_bot_via_dialog_id = guest_bot_via_dialog_id.is_valid();
   bool has_receiver_user_id = receiver_user_id.is_valid();
   bool has_ephemeral_message_id = ephemeral_message_id.is_valid();
+  bool has_send_callback_query_id = send_callback_query_id != 0;
   BEGIN_STORE_FLAGS();
   STORE_FLAG(is_channel_post);
   STORE_FLAG(is_outgoing);
@@ -2485,6 +2489,7 @@ void MessagesManager::Message::store(StorerT &storer) const {
     STORE_FLAG(has_guest_bot_via_dialog_id);
     STORE_FLAG(has_receiver_user_id);
     STORE_FLAG(has_ephemeral_message_id);
+    STORE_FLAG(has_send_callback_query_id);
     END_STORE_FLAGS();
   }
   // update MessageDb::get_message_info when flags5 is added
@@ -2648,6 +2653,9 @@ void MessagesManager::Message::store(StorerT &storer) const {
   if (has_ephemeral_message_id) {
     store(ephemeral_message_id, storer);
   }
+  if (has_send_callback_query_id) {
+    store(send_callback_query_id, storer);
+  }
 }
 
 // do not forget to resolve message dependencies
@@ -2719,6 +2727,7 @@ void MessagesManager::Message::parse(ParserT &parser) {
   bool has_guest_bot_via_dialog_id = false;
   bool has_receiver_user_id = false;
   bool has_ephemeral_message_id = false;
+  bool has_send_callback_query_id = false;
   BEGIN_PARSE_FLAGS();
   PARSE_FLAG(is_channel_post);
   PARSE_FLAG(is_outgoing);
@@ -2830,6 +2839,7 @@ void MessagesManager::Message::parse(ParserT &parser) {
     PARSE_FLAG(has_guest_bot_via_dialog_id);
     PARSE_FLAG(has_receiver_user_id);
     PARSE_FLAG(has_ephemeral_message_id);
+    PARSE_FLAG(has_send_callback_query_id);
     END_PARSE_FLAGS();
   }
 
@@ -3064,6 +3074,9 @@ void MessagesManager::Message::parse(ParserT &parser) {
       parser.set_error("Invalid ephemeral message identifier");
     }
   }
+  if (has_send_callback_query_id) {
+    parse(send_callback_query_id, parser);
+  }
 
   CHECK(content != nullptr);
   is_content_secret |= ttl.is_secret_message_content(content->get_type());  // repair is_content_secret for old messages
@@ -22124,10 +22137,11 @@ void MessagesManager::do_send_message_media(DialogId dialog_id, const Message *m
         td_->create_handler<SendMediaQuery>()->send(
             m->file_upload_ids, m->thumbnail_file_upload_ids,
             get_message_content_cover_any_file_ids(td_, m->content.get()), get_message_flags(m), dialog_id,
-            get_send_message_as_input_peer(m), m->receiver_user_id, *get_message_input_reply_to(m),
-            get_send_message_topic(dialog_id, m), get_message_schedule_date(m), get_message_schedule_repeat_period(m),
-            m->effect_id, m->paid_message_star_count, m->suggested_post.get(), m->reply_markup, caption,
-            std::move(input_media), m->content->get_type(), m->is_copy, random_id, &m->send_query_ref);
+            get_send_message_as_input_peer(m), m->receiver_user_id, m->send_callback_query_id,
+            *get_message_input_reply_to(m), get_send_message_topic(dialog_id, m), get_message_schedule_date(m),
+            get_message_schedule_repeat_period(m), m->effect_id, m->paid_message_star_count, m->suggested_post.get(),
+            m->reply_markup, caption, std::move(input_media), m->content->get_type(), m->is_copy, random_id,
+            &m->send_query_ref);
       }));
 }
 
@@ -22633,10 +22647,10 @@ void MessagesManager::on_text_message_ready_to_send(DialogId dialog_id, MessageI
     } else {
       td_->create_handler<SendMediaQuery>()->send(
           {}, {}, {}, get_message_flags(m), dialog_id, get_send_message_as_input_peer(m), m->receiver_user_id,
-          *get_message_input_reply_to(m), get_send_message_topic(dialog_id, m), get_message_schedule_date(m),
-          get_message_schedule_repeat_period(m), m->effect_id, m->paid_message_star_count, m->suggested_post.get(),
-          m->reply_markup, message_text, std::move(input_media), MessageContentType::Text, m->is_copy, random_id,
-          &m->send_query_ref);
+          m->send_callback_query_id, *get_message_input_reply_to(m), get_send_message_topic(dialog_id, m),
+          get_message_schedule_date(m), get_message_schedule_repeat_period(m), m->effect_id, m->paid_message_star_count,
+          m->suggested_post.get(), m->reply_markup, message_text, std::move(input_media), MessageContentType::Text,
+          m->is_copy, random_id, &m->send_query_ref);
     }
   }
 }
@@ -25230,8 +25244,8 @@ void MessagesManager::process_suggested_post(MessageFullId message_full_id, bool
 
 Result<td_api::object_ptr<td_api::message>> MessagesManager::send_ephemeral_message(
     DialogId dialog_id, const td_api::object_ptr<td_api::MessageTopic> &topic_id, UserId receiver_user_id,
-    td_api::object_ptr<td_api::InputMessageReplyTo> &&reply_to, int32 sending_id, bool only_preview,
-    td_api::object_ptr<td_api::ReplyMarkup> &&reply_markup,
+    int64 callback_query_id, td_api::object_ptr<td_api::InputMessageReplyTo> &&reply_to, int32 sending_id,
+    bool only_preview, td_api::object_ptr<td_api::ReplyMarkup> &&reply_markup,
     td_api::object_ptr<td_api::InputMessageContent> &&input_message_content) {
   if (input_message_content == nullptr) {
     return Status::Error(400, "Can't send message without content");
@@ -25291,6 +25305,7 @@ Result<td_api::object_ptr<td_api::message>> MessagesManager::send_ephemeral_mess
     m->is_content_secret = m->ttl.is_secret_message_content(m->content->get_type());
   }
   m->send_emoji = std::move(message_content.emoji);
+  m->send_callback_query_id = callback_query_id;
 
   if (only_preview) {
     return get_message_object(dialog_id, m, "send_ephemeral_message");
diff --git a/td/telegram/MessagesManager.h b/td/telegram/MessagesManager.h
index 5d62f410b..60bb4a1e7 100644
--- a/td/telegram/MessagesManager.h
+++ b/td/telegram/MessagesManager.h
@@ -501,8 +501,8 @@ class MessagesManager final : public Actor {
 
   Result<td_api::object_ptr<td_api::message>> send_ephemeral_message(
       DialogId dialog_id, const td_api::object_ptr<td_api::MessageTopic> &topic_id, UserId receiver_user_id,
-      td_api::object_ptr<td_api::InputMessageReplyTo> &&reply_to, int32 sending_id, bool only_preview,
-      tl_object_ptr<td_api::ReplyMarkup> &&reply_markup,
+      int64 callback_query_id, td_api::object_ptr<td_api::InputMessageReplyTo> &&reply_to, int32 sending_id,
+      bool only_preview, tl_object_ptr<td_api::ReplyMarkup> &&reply_markup,
       tl_object_ptr<td_api::InputMessageContent> &&input_message_content) TD_WARN_UNUSED_RESULT;
 
   Result<MessageId> add_local_message(
@@ -1137,6 +1137,7 @@ class MessagesManager final : public Actor {
     MessageId initial_top_thread_message_id;                 // for send_message
     MessageInputReplyTo input_reply_to;                      // for send_message
     int64 reply_to_random_id = 0;                            // for send_message
+    int64 send_callback_query_id = 0;                        // for send_message
     string send_emoji;                                       // for send_message
     int32 new_video_start_timestamp = 0;                     // for send_message
     mutable vector<FileUploadId> file_upload_ids;            // for send_message
diff --git a/td/telegram/Requests.cpp b/td/telegram/Requests.cpp
index 0554c17ee..faf6823ca 100644
--- a/td/telegram/Requests.cpp
+++ b/td/telegram/Requests.cpp
@@ -4256,8 +4256,8 @@ void Requests::on_request(uint64 id, td_api::sendInlineQueryResultMessage &reque
 
 void Requests::on_request(uint64 id, td_api::sendEphemeralMessage &request) {
   auto r_sent_message = td_->messages_manager_->send_ephemeral_message(
-      DialogId(request.chat_id_), request.topic_id_, UserId(request.receiver_user_id_), std::move(request.reply_to_),
-      request.sending_id_, request.only_preview_, std::move(request.reply_markup_),
+      DialogId(request.chat_id_), request.topic_id_, UserId(request.receiver_user_id_), request.callback_query_id_,
+      std::move(request.reply_to_), request.sending_id_, request.only_preview_, std::move(request.reply_markup_),
       std::move(request.input_message_content_));
   if (r_sent_message.is_error()) {
     send_closure(td_actor_, &Td::send_error, id, r_sent_message.move_as_error());
diff --git a/td/telegram/cli.cpp b/td/telegram/cli.cpp
index 785b8e135..095be1e5d 100644
--- a/td/telegram/cli.cpp
+++ b/td/telegram/cli.cpp
@@ -2951,7 +2951,7 @@ class CliClient final : public Actor {
                     bool disable_notification = false, bool from_background = false) {
     if (ephemeral_message_receiver_id_ != 0) {
       send_request(td_api::make_object<td_api::sendEphemeralMessage>(
-          chat_id, get_message_topic_id(), ephemeral_message_receiver_id_, get_input_message_reply_to(), 123,
+          chat_id, get_message_topic_id(), ephemeral_message_receiver_id_, 0, get_input_message_reply_to(), 123,
           only_preview_, nullptr, std::move(input_message_content)));
       return;
     }