Support telegram_api::updateEphemeralBotCallbackQuery.

Author: levlam

td/telegram/CallbackQueriesManager.cpp

@@ -241,6 +241,37 @@ void CallbackQueriesManager::on_new_query(int64 callback_query_id, UserId sender
                    chat_instance, std::move(payload)));
 }
 
+void CallbackQueriesManager::on_new_ephemeral_query(
+    int64 callback_query_id, UserId sender_user_id, BufferSlice &&data,
+    telegram_api::object_ptr<telegram_api::ephemeralMessage> &&message) {
+  if (!sender_user_id.is_valid()) {
+    LOG(ERROR) << "Receive new ephemeral callback query from invalid " << sender_user_id;
+    return;
+  }
+  LOG_IF(ERROR, !td_->user_manager_->have_min_user(sender_user_id)) << "Receive unknown " << sender_user_id;
+  if (!td_->auth_manager_->is_bot()) {
+    LOG(ERROR) << "Receive new callback query";
+    return;
+  }
+
+  auto payload = get_query_payload(std::move(data), string());
+  if (payload == nullptr) {
+    return;
+  }
+
+  auto message_full_id = td_->messages_manager_->on_edited_ephemeral_message(std::move(message), true);
+  if (!message_full_id.get_message_id().is_local()) {
+    LOG(ERROR) << "Receive ephemeral callback query from " << message_full_id;
+    return;
+  }
+
+  send_closure(G()->td(), &Td::send_update,
+               td_api::make_object<td_api::updateNewCallbackQuery>(
+                   callback_query_id, td_->user_manager_->get_user_id_object(sender_user_id, "updateNewCallbackQuery"),
+                   td_->dialog_manager_->get_chat_id_object(message_full_id.get_dialog_id(), "updateNewCallbackQuery"),
+                   message_full_id.get_message_id().get(), 0, std::move(payload)));
+}
+
 void CallbackQueriesManager::on_new_inline_query(
     int64 callback_query_id, UserId sender_user_id,
     tl_object_ptr<telegram_api::InputBotInlineMessageID> &&inline_message_id, BufferSlice &&data, int64 chat_instance,

td/telegram/CallbackQueriesManager.h

@@ -31,6 +31,9 @@ class CallbackQueriesManager {
   void on_new_query(int64 callback_query_id, UserId sender_user_id, DialogId dialog_id, MessageId message_id,
                     BufferSlice &&data, int64 chat_instance, string &&game_short_name);
 
+  void on_new_ephemeral_query(int64 callback_query_id, UserId sender_user_id, BufferSlice &&data,
+                              telegram_api::object_ptr<telegram_api::ephemeralMessage> &&message);
+
   void on_new_inline_query(int64 callback_query_id, UserId sender_user_id,
                            tl_object_ptr<telegram_api::InputBotInlineMessageID> &&inline_message_id, BufferSlice &&data,
                            int64 chat_instance, string &&game_short_name);

td/telegram/MessagesManager.cpp

@@ -4306,18 +4306,28 @@ void MessagesManager::on_new_ephemeral_message(telegram_api::object_ptr<telegram
   on_get_message(std::move(message_info), true, "on_new_ephemeral_message");
 }
 
-void MessagesManager::on_edited_ephemeral_message(telegram_api::object_ptr<telegram_api::ephemeralMessage> &&message) {
+MessageFullId MessagesManager::on_edited_ephemeral_message(
+    telegram_api::object_ptr<telegram_api::ephemeralMessage> &&message, bool force) {
   auto message_info = parse_ephemeral_message(td_, std::move(message), "on_edited_ephemeral_message");
   auto dialog_id = message_info.dialog_id;
   if (!dialog_id.is_valid()) {
-    return;
+    return MessageFullId();
   }
 
   message_info.message_id = get_message_id_of_ephemeral_message_id(dialog_id, message_info.ephemeral_message_id);
   if (message_info.message_id == MessageId()) {
-    return;
+    if (!force) {
+      return MessageFullId();
+    }
+    force_create_dialog(dialog_id, "on_edited_ephemeral_message", true);
+    Dialog *d = get_dialog(dialog_id);
+    if (d == nullptr) {
+      return MessageFullId();
+    }
+    CHECK(d->ephemeral_message_ids.count(message_info.ephemeral_message_id) == 0);
+    message_info.message_id = get_next_local_message_id(d);
   }
-  on_get_message(std::move(message_info), false, "on_edited_ephemeral_message");
+  return on_get_message(std::move(message_info), false, "on_edited_ephemeral_message");
 }
 
 void MessagesManager::on_delete_ephemeral_messages(DialogId dialog_id,

td/telegram/MessagesManager.h

@@ -323,7 +323,8 @@ class MessagesManager final : public Actor {
 
   void on_new_ephemeral_message(telegram_api::object_ptr<telegram_api::ephemeralMessage> &&message);
 
-  void on_edited_ephemeral_message(telegram_api::object_ptr<telegram_api::ephemeralMessage> &&message);
+  MessageFullId on_edited_ephemeral_message(telegram_api::object_ptr<telegram_api::ephemeralMessage> &&message,
+                                            bool force = false);
 
   void on_delete_ephemeral_messages(DialogId dialog_id, vector<EphemeralMessageId> ephemeral_message_ids);
 

td/telegram/UpdatesManager.cpp

@@ -4513,6 +4513,13 @@ void UpdatesManager::on_update(tl_object_ptr<telegram_api::updateBotCallbackQuer
   promise.set_value(Unit());
 }
 
+void UpdatesManager::on_update(tl_object_ptr<telegram_api::updateEphemeralBotCallbackQuery> update,
+                               Promise<Unit> &&promise) {
+  td_->callback_queries_manager_->on_new_ephemeral_query(update->query_id_, UserId(update->user_id_),
+                                                         std::move(update->data_), std::move(update->message_));
+  promise.set_value(Unit());
+}
+
 void UpdatesManager::on_update(tl_object_ptr<telegram_api::updateInlineBotCallbackQuery> update,
                                Promise<Unit> &&promise) {
   td_->callback_queries_manager_->on_new_inline_query(update->query_id_, UserId(update->user_id_),
@@ -5092,9 +5099,4 @@ void UpdatesManager::on_update(tl_object_ptr<telegram_api::updateNewStoryReactio
   promise.set_value(Unit());
 }
 
-void UpdatesManager::on_update(tl_object_ptr<telegram_api::updateEphemeralBotCallbackQuery> update,
-                               Promise<Unit> &&promise) {
-  promise.set_value(Unit());
-}
-
 }  // namespace td

td/telegram/UpdatesManager.h

@@ -633,6 +633,7 @@ class UpdatesManager final : public Actor {
   void on_update(tl_object_ptr<telegram_api::updateBotInlineSend> update, Promise<Unit> &&promise);
 
   void on_update(tl_object_ptr<telegram_api::updateBotCallbackQuery> update, Promise<Unit> &&promise);
+  void on_update(tl_object_ptr<telegram_api::updateEphemeralBotCallbackQuery> update, Promise<Unit> &&promise);
   void on_update(tl_object_ptr<telegram_api::updateInlineBotCallbackQuery> update, Promise<Unit> &&promise);
   void on_update(tl_object_ptr<telegram_api::updateBusinessBotCallbackQuery> update, Promise<Unit> &&promise);
 
@@ -785,8 +786,6 @@ class UpdatesManager final : public Actor {
   // unsupported updates
 
   void on_update(tl_object_ptr<telegram_api::updateNewStoryReaction> update, Promise<Unit> &&promise);
-
-  void on_update(tl_object_ptr<telegram_api::updateEphemeralBotCallbackQuery> update, Promise<Unit> &&promise);
 };
 
 }  // namespace td