Add td_api::getSavedMessagesTopicHistory.

td/generate/scheme/td_api.tl

@@ -1869,7 +1869,7 @@ savedMessagesTopicAuthorHidden = SavedMessagesTopic;
 savedMessagesTopicSavedFromChat chat_id:int53 = SavedMessagesTopic;
 
 
-//@description Contains information about a found saved messages topic @topic The topic @last_message Last message in the topic; may be null if none or unknown
+//@description Contains information about a found Saved Messages topic @topic The topic @last_message Last message in the topic; may be null if none or unknown
 foundSavedMessagesTopic topic:SavedMessagesTopic last_message:message = FoundSavedMessagesTopic;
 
 //@description Contains a list of Saved Messages topics
@@ -7155,14 +7155,23 @@ getSuitableDiscussionChats = Chats;
 //@description Returns a list of recently inactive supergroups and channels. Can be used when user reaches limit on the number of joined supergroups and channels and receives CHANNELS_TOO_MUCH error. Also, the limit can be increased with Telegram Premium
 getInactiveSupergroupChats = Chats;
 
-//@description Returns list of all pinned saved messages topics
+
+//@description Returns list of all pinned Saved Messages topics
 getPinnedSavedMessagesTopics = FoundSavedMessagesTopics;
 
-//@description Returns list of non-pinned saved messages topics from the specified offset
+//@description Returns list of non-pinned Saved Messages topics from the specified offset
 //@offset Offset of the first entry to return as received from the previous request; use empty string to get the first chunk of results
-//@limit The maximum number of saved messages topics to be returned; up to 100
+//@limit The maximum number of Saved Messages topics to be returned; up to 100
 getSavedMessagesTopics offset:string limit:int32 = FoundSavedMessagesTopics;
 
+//@description Returns messages in a Saved Messages topic. The messages are returned in a reverse chronological order (i.e., in order of decreasing message_id)
+//@saved_messages_topic Saved Messages topic which messages will be fetched
+//@from_message_id Identifier of the message starting from which messages must be fetched; use 0 to get results from the last message
+//@offset Specify 0 to get results from exactly the from_message_id or a negative offset up to 99 to get additionally some newer messages
+//@limit The maximum number of messages to be returned; must be positive and can't be greater than 100. If the offset is negative, the limit must be greater than or equal to -offset.
+//-For optimal performance, the number of returned messages is chosen by TDLib and can be smaller than the specified limit
+getSavedMessagesTopicHistory saved_messages_topic:SavedMessagesTopic from_message_id:int53 offset:int32 limit:int32 = Messages;
+
 
 //@description Returns a list of common group chats with a given user. Chats are sorted by their type and creation date
 //@user_id User identifier

td/telegram/MessagesManager.cpp

@@ -250,6 +250,57 @@ class GetSavedDialogsQuery final : public Td::ResultHandler {
   }
 };
 
+class GetSavedHistoryQuery final : public Td::ResultHandler {
+  Promise<td_api::object_ptr<td_api::messages>> promise_;
+  SavedMessagesTopicId saved_messages_topic_id_;
+
+ public:
+  explicit GetSavedHistoryQuery(Promise<td_api::object_ptr<td_api::messages>> &&promise)
+      : promise_(std::move(promise)) {
+  }
+
+  void send(SavedMessagesTopicId saved_messages_topic_id, MessageId from_message_id, int32 offset, int32 limit) {
+    saved_messages_topic_id_ = saved_messages_topic_id;
+    telegram_api::object_ptr<telegram_api::InputPeer> saved_input_peer = saved_messages_topic_id.get_input_peer(td_);
+    CHECK(saved_input_peer != nullptr);
+    send_query(G()->net_query_creator().create(telegram_api::messages_getSavedHistory(
+        std::move(saved_input_peer), from_message_id.get_server_message_id().get(), 0, offset, limit, 0, 0, 0)));
+  }
+
+  void on_result(BufferSlice packet) final {
+    auto result_ptr = fetch_result<telegram_api::messages_getSavedHistory>(packet);
+    if (result_ptr.is_error()) {
+      return on_error(result_ptr.move_as_error());
+    }
+
+    auto result = result_ptr.move_as_ok();
+    LOG(INFO) << "Receive Saved Messages topic history: " << to_string(result);
+    auto info =
+        get_messages_info(td_, td_->dialog_manager_->get_my_dialog_id(), std::move(result), "GetSavedHistoryQuery");
+    LOG_IF(ERROR, info.is_channel_messages) << "Receive channel messages in GetSavedHistoryQuery";
+
+    auto my_dialog_id = td_->dialog_manager_->get_my_dialog_id();
+    vector<td_api::object_ptr<td_api::message>> messages;
+    for (auto &message : info.messages) {
+      auto full_message_id =
+          td_->messages_manager_->on_get_message(std::move(message), false, false, false, "GetSavedHistoryQuery");
+      auto dialog_id = full_message_id.get_dialog_id();
+      if (dialog_id != my_dialog_id) {
+        if (dialog_id != DialogId()) {
+          LOG(ERROR) << "Receive " << full_message_id << " in history of " << saved_messages_topic_id_;
+        }
+        continue;
+      }
+      messages.push_back(td_->messages_manager_->get_message_object(full_message_id, "GetSavedHistoryQuery"));
+    }
+    promise_.set_value(td_api::make_object<td_api::messages>(info.total_count, std::move(messages)));
+  }
+
+  void on_error(Status status) final {
+    promise_.set_error(std::move(status));
+  }
+};
+
 class GetDialogUnreadMarksQuery final : public Td::ResultHandler {
  public:
   void send() {
@@ -16047,6 +16098,42 @@ void MessagesManager::on_get_saved_messages_topics(
       total_count, std::move(found_saved_messages_topics), next_offset));
 }
 
+void MessagesManager::get_saved_messages_topic_history(SavedMessagesTopicId saved_messages_topic_id,
+                                                       MessageId from_message_id, int32 offset, int32 limit,
+                                                       Promise<td_api::object_ptr<td_api::messages>> &&promise) {
+  if (limit <= 0) {
+    return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
+  }
+  if (limit > MAX_GET_HISTORY) {
+    limit = MAX_GET_HISTORY;
+  }
+  if (offset > 0) {
+    return promise.set_error(Status::Error(400, "Parameter offset must be non-positive"));
+  }
+  if (offset <= -MAX_GET_HISTORY) {
+    return promise.set_error(Status::Error(400, "Parameter offset must be greater than -100"));
+  }
+  if (offset < -limit) {
+    return promise.set_error(Status::Error(400, "Parameter offset must be greater than or equal to -limit"));
+  }
+
+  auto my_dialog_id = td_->dialog_manager_->get_my_dialog_id();
+  if (!saved_messages_topic_id.is_valid()) {
+    return promise.set_error(Status::Error(400, "Invalid Saved Messages topic specified"));
+  }
+  TRY_STATUS_PROMISE(promise, saved_messages_topic_id.is_valid_in(td_, my_dialog_id));
+
+  if (from_message_id == MessageId() || from_message_id.get() > MessageId::max().get()) {
+    from_message_id = MessageId::max();
+  }
+  if (!from_message_id.is_valid() || !from_message_id.is_server()) {
+    return promise.set_error(Status::Error(400, "Invalid value of parameter from_message_id specified"));
+  }
+
+  td_->create_handler<GetSavedHistoryQuery>(std::move(promise))
+      ->send(saved_messages_topic_id, from_message_id, offset, limit);
+}
+
 vector<DialogId> MessagesManager::search_public_dialogs(const string &query, Promise<Unit> &&promise) {
   LOG(INFO) << "Search public chats with query = \"" << query << '"';
 

td/telegram/MessagesManager.h

@@ -537,6 +537,10 @@ class MessagesManager final : public Actor {
   void on_get_saved_messages_topics(telegram_api::object_ptr<telegram_api::messages_SavedDialogs> &&saved_dialogs_ptr,
                                     Promise<td_api::object_ptr<td_api::foundSavedMessagesTopics>> &&promise);
 
+  void get_saved_messages_topic_history(SavedMessagesTopicId saved_messages_topic_id, MessageId from_message_id,
+                                        int32 offset, int32 limit,
+                                        Promise<td_api::object_ptr<td_api::messages>> &&promise);
+
   vector<DialogId> search_public_dialogs(const string &query, Promise<Unit> &&promise);
 
   std::pair<int32, vector<DialogId>> search_dialogs(const string &query, int32 limit, Promise<Unit> &&promise);

td/telegram/Td.cpp

@@ -5034,6 +5034,14 @@ void Td::on_request(uint64 id, const td_api::getSavedMessagesTopics &request) {
   messages_manager_->get_saved_messages_topics(request.offset_, request.limit_, std::move(promise));
 }
 
+void Td::on_request(uint64 id, const td_api::getSavedMessagesTopicHistory &request) {
+  CHECK_IS_USER();
+  CREATE_REQUEST_PROMISE();
+  messages_manager_->get_saved_messages_topic_history(SavedMessagesTopicId(this, request.saved_messages_topic_),
+                                                      MessageId(request.from_message_id_), request.offset_,
+                                                      request.limit_, std::move(promise));
+}
+
 void Td::on_request(uint64 id, td_api::searchPublicChat &request) {
   CLEAN_INPUT_STRING(request.username_);
   CREATE_REQUEST(SearchPublicChatRequest, request.username_);

td/telegram/Td.h

@@ -675,6 +675,8 @@ class Td final : public Actor {
 
   void on_request(uint64 id, const td_api::getSavedMessagesTopics &request);
 
+  void on_request(uint64 id, const td_api::getSavedMessagesTopicHistory &request);
+
   void on_request(uint64 id, td_api::searchPublicChat &request);
 
   void on_request(uint64 id, td_api::searchPublicChats &request);

td/telegram/cli.cpp

@@ -2757,13 +2757,20 @@ class CliClient final : public Actor {
       string offset;
       get_args(args, limit, offset);
       send_request(td_api::make_object<td_api::getSavedMessagesTopics>(offset, as_limit(limit)));
+    } else if (op == "gsmth") {
+      MessageId from_message_id;
+      int32 offset;
+      string limit;
+      get_args(args, from_message_id, offset, limit);
+      send_request(td_api::make_object<td_api::getSavedMessagesTopicHistory>(get_saved_messages_topic(),
+                                                                             from_message_id, offset, as_limit(limit)));
     } else if (op == "gcc" || op == "GetCommonChats") {
       UserId user_id;
       ChatId offset_chat_id;
       string limit;
       get_args(args, user_id, offset_chat_id, limit);
       send_request(td_api::make_object<td_api::getGroupsInCommon>(user_id, offset_chat_id, as_limit(limit, 100)));
-    } else if (op == "gh" || op == "GetHistory" || op == "ghl" || op == "gmth") {
+    } else if (op == "gh" || op == "ghl" || op == "gmth") {
       ChatId chat_id;
       MessageId thread_message_id;
       MessageId from_message_id;