Add "guest_message" updates.

telegram-bot-api/Client.cpp

@@ -4094,6 +4094,9 @@ void Client::JsonMessage::store(td::JsonValueScope *scope) const {
   if (message_->media_album_id != 0) {
     object("media_group_id", td::to_string(message_->media_album_id));
   }
+  if (message_->guest_query_id != 0) {
+    object("guest_query_id", td::to_string(message_->guest_query_id));
+  }
   switch (message_->content->get_id()) {
     case td_api::messageText::ID: {
       auto content = static_cast<const td_api::messageText *>(message_->content.get());
@@ -9053,6 +9056,9 @@ void Client::on_update(object_ptr<td_api::Object> result) {
     case td_api::updateBusinessMessagesDeleted::ID:
       add_update_business_messages_deleted(move_object_as<td_api::updateBusinessMessagesDeleted>(result));
       break;
+    case td_api::updateNewGuestQuery::ID:
+      add_new_guest_query(move_object_as<td_api::updateNewGuestQuery>(result));
+      break;
     case td_api::updateConnectionState::ID: {
       auto update = move_object_as<td_api::updateConnectionState>(result);
       if (update->state_->get_id() == td_api::connectionStateReady::ID) {
@@ -16591,6 +16597,8 @@ td::Slice Client::get_update_type_name(UpdateType update_type) {
       return td::Slice("purchased_paid_media");
     case UpdateType::ManagedBot:
       return td::Slice("managed_bot");
+    case UpdateType::GuestMessage:
+      return td::Slice("guest_message");
     default:
       UNREACHABLE();
       return td::Slice();
@@ -17081,6 +17089,18 @@ void Client::add_business_message_edited(object_ptr<td_api::updateBusinessMessag
   process_new_business_message_queue(update->connection_id_, 0);
 }
 
+void Client::add_new_guest_query(object_ptr<td_api::updateNewGuestQuery> &&update) {
+  CHECK(update != nullptr);
+  auto message_info = create_message(std::move(update->message_));
+  message_info->reference_messages =
+      transform(std::move(update->reference_messages_),
+                [&](object_ptr<td_api::message> &&message) { return create_message(std::move(message)); });
+  message_info->guest_query_id = update->id_;
+  auto chat_id = message_info->chat_id;
+  new_guest_query_queues_[chat_id].queue_.emplace(std::move(message_info));
+  process_new_guest_query_queue(chat_id, 0);
+}
+
 td::int64 Client::choose_added_member_id(const td_api::messageChatAddMembers *message_add_members) const {
   CHECK(message_add_members != nullptr);
   for (auto &member_user_id : message_add_members->member_user_ids_) {
@@ -17584,6 +17604,9 @@ td::vector<td::int64> Client::get_message_sticker_set_ids(const MessageInfo *mes
   if (message_info->business_reply_to_message != nullptr) {
     td::combine(sticker_set_ids, get_message_sticker_set_ids(message_info->business_reply_to_message.get()));
   }
+  for (const auto &reference_message : message_info->reference_messages) {
+    td::combine(sticker_set_ids, get_message_sticker_set_ids(reference_message.get()));
+  }
   return sticker_set_ids;
 }
 
@@ -17704,6 +17727,50 @@ void Client::process_new_business_message_queue(const td::string &connection_id,
   new_business_message_queues_.erase(connection_id);
 }
 
+void Client::process_new_guest_query_queue(int64 chat_id, int state) {
+  auto &queue = new_guest_query_queues_[chat_id];
+  if (queue.has_active_request_) {
+    if (state != 0) {
+      queue.has_active_request_ = false;
+    } else {
+      return;
+    }
+  } else {
+    CHECK(state == 0);
+  }
+  if (logging_out_ || closing_) {
+    new_guest_query_queues_.erase(chat_id);
+    return;
+  }
+  while (!queue.queue_.empty()) {
+    auto &query = queue.queue_.front();
+    if (state == 0) {
+      auto sticker_set_ids = get_message_sticker_set_ids(query.message_info_.get());
+      if (!sticker_set_ids.empty()) {
+        queue.has_active_request_ = true;
+        return get_sticker_set_names(std::move(sticker_set_ids),
+                                     td::PromiseCreator::lambda([actor_id = actor_id(this), chat_id](td::Unit) {
+                                       send_closure(actor_id, &Client::process_new_guest_query_queue, chat_id, 1);
+                                     }));
+      }
+      state = 1;
+    }
+    CHECK(state == 1);
+
+    auto message_info = std::move(query.message_info_);
+    queue.queue_.pop();
+
+    state = 0;
+    if (need_skip_update_message(0, message_info.get(), false)) {
+      continue;
+    }
+
+    auto webhook_queue_id = message_info->chat_id + (static_cast<int64>(12) << 33);
+    add_message_update(UpdateType::GuestMessage, message_info.get(), webhook_queue_id);
+  }
+  new_guest_query_queues_.erase(chat_id);
+}
+
 td::unique_ptr<Client::MessageInfo> Client::delete_message(int64 chat_id, int64 message_id, bool only_from_cache) {
   auto message_info = std::move(messages_[{chat_id, message_id}]);
   if (message_info == nullptr) {

telegram-bot-api/Client.h

@@ -1140,10 +1140,12 @@ class Client final : public WebhookActor::Callback {
     int32 initial_send_date = 0;
     int32 sender_boost_count = 0;
     int64 paid_message_star_count = 0;
+    int64 guest_query_id = 0;
     object_ptr<td_api::MessageOrigin> forward_origin;
     td::string author_signature;
     td::string sender_tag;
     td::unique_ptr<MessageInfo> business_reply_to_message;
+    td::vector<td::unique_ptr<MessageInfo>> reference_messages;
     object_ptr<td_api::messageReplyToMessage> reply_to_message;
     object_ptr<td_api::messageReplyToStory> reply_to_story;
     object_ptr<td_api::MessageTopic> topic_id;
@@ -1248,6 +1250,10 @@ class Client final : public WebhookActor::Callback {
 
   void process_new_business_message_queue(const td::string &connection_id, int state);
 
+  void add_new_guest_query(object_ptr<td_api::updateNewGuestQuery> &&update);
+
+  void process_new_guest_query_queue(int64 chat_id, int state);
+
   struct MessageFullId {
     int64 chat_id;
     int64 message_id;
@@ -1385,6 +1391,7 @@ class Client final : public WebhookActor::Callback {
     BusinessMessagesDeleted,
     PurchasedPaidMedia,
     ManagedBot,
+    GuestMessage,
     Size
   };
 
@@ -1513,6 +1520,18 @@ class Client final : public WebhookActor::Callback {
   };
   td::FlatHashMap<td::string, NewBusinessMessageQueue> new_business_message_queues_;  // connection_id -> queue
 
+  struct NewGuestQuery {
+    td::unique_ptr<MessageInfo> message_info_;
+
+    explicit NewGuestQuery(td::unique_ptr<MessageInfo> &&message_info) : message_info_(std::move(message_info)) {
+    }
+  };
+  struct NewGuestQueryQueue {
+    std::queue<NewGuestQuery> queue_;
+    bool has_active_request_ = false;
+  };
+  td::FlatHashMap<int64, NewGuestQueryQueue> new_guest_query_queues_;  // chat_id -> queue
+
   struct NewCallbackQueryQueue {
     std::queue<object_ptr<td_api::updateNewCallbackQuery>> queue_;
     bool has_active_request_ = false;