Add td_api::reorderChatFilters.

GitOrigin-RevId: 33fe529db5e96b6dfc15fc86b1b635fb412091b2

td/generate/scheme/td_api.tl

@@ -3718,6 +3718,9 @@ editChatFilter chat_filter_id:int32 filter:chatFilter = Ok;
 //@description Deletes existing chat filter @chat_filter_id Chat filter identifier
 deleteChatFilter chat_filter_id:int32 = Ok;
 
+//@description Changes the order of chat filters @chat_filter_ids Identifiers of chat filters in the new correct order
+reorderChatFilters chat_filter_ids:vector<int32> = Ok;
+
 
 //@description Changes the chat title. Supported only for basic groups, supergroups and channels. Requires can_change_info rights. The title will not be changed until the request to the server has been completed
 //@chat_id Chat identifier @title New title of the chat; 1-128 characters

td/telegram/MessagesManager.cpp

@@ -111,6 +111,64 @@ class GetDialogFiltersQuery : public Td::ResultHandler {
   }
 };
 
+class UpdateDialogFilterQuery : public Td::ResultHandler {
+  Promise<Unit> promise_;
+
+ public:
+  explicit UpdateDialogFilterQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
+  }
+
+  void send(DialogFilterId dialog_filter_id, tl_object_ptr<telegram_api::dialogFilter> filter) {
+    int32 flags = 0;
+    if (filter != nullptr) {
+      flags |= telegram_api::messages_updateDialogFilter::FILTER_MASK;
+    }
+    send_query(G()->net_query_creator().create(
+        telegram_api::messages_updateDialogFilter(flags, dialog_filter_id.get(), std::move(filter))));
+  }
+
+  void on_result(uint64 id, BufferSlice packet) override {
+    auto result_ptr = fetch_result<telegram_api::messages_updateDialogFilter>(packet);
+    if (result_ptr.is_error()) {
+      return on_error(id, result_ptr.move_as_error());
+    }
+
+    LOG(INFO) << "Receive result for UpdateDialogFilterQuery: " << result_ptr.ok();
+    promise_.set_value(Unit());
+  }
+
+  void on_error(uint64 id, Status status) override {
+    promise_.set_error(std::move(status));
+  }
+};
+
+class ReorderDialogFiltersQuery : public Td::ResultHandler {
+  Promise<Unit> promise_;
+
+ public:
+  explicit ReorderDialogFiltersQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
+  }
+
+  void send(vector<DialogFilterId> dialog_filter_ids) {
+    send_query(G()->net_query_creator().create(telegram_api::messages_updateDialogFiltersOrder(
+        transform(dialog_filter_ids, [](auto dialog_filter_id) { return dialog_filter_id.get(); }))));
+  }
+
+  void on_result(uint64 id, BufferSlice packet) override {
+    auto result_ptr = fetch_result<telegram_api::messages_updateDialogFiltersOrder>(packet);
+    if (result_ptr.is_error()) {
+      return on_error(id, result_ptr.move_as_error());
+    }
+
+    LOG(INFO) << "Receive result for UpdateDialogFiltersOrderQuery: " << result_ptr.ok();
+    promise_.set_value(Unit());
+  }
+
+  void on_error(uint64 id, Status status) override {
+    promise_.set_error(std::move(status));
+  }
+};
+
 class GetOnlinesQuery : public Td::ResultHandler {
   DialogId dialog_id_;
 
@@ -425,37 +483,6 @@ class GetScheduledMessagesQuery : public Td::ResultHandler {
   }
 };
 
-class UpdateDialogFilterQuery : public Td::ResultHandler {
-  Promise<Unit> promise_;
-
- public:
-  explicit UpdateDialogFilterQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
-  }
-
-  void send(DialogFilterId dialog_filter_id, tl_object_ptr<telegram_api::dialogFilter> filter) {
-    int32 flags = 0;
-    if (filter != nullptr) {
-      flags |= telegram_api::messages_updateDialogFilter::FILTER_MASK;
-    }
-    send_query(G()->net_query_creator().create(
-        telegram_api::messages_updateDialogFilter(flags, dialog_filter_id.get(), std::move(filter))));
-  }
-
-  void on_result(uint64 id, BufferSlice packet) override {
-    auto result_ptr = fetch_result<telegram_api::messages_updateDialogFilter>(packet);
-    if (result_ptr.is_error()) {
-      return on_error(id, result_ptr.move_as_error());
-    }
-
-    LOG(INFO) << "Receive result for UpdateDialogFilterQuery: " << result_ptr.ok();
-    promise_.set_value(Unit());
-  }
-
-  void on_error(uint64 id, Status status) override {
-    promise_.set_error(std::move(status));
-  }
-};
-
 class UpdateDialogPinnedMessageQuery : public Td::ResultHandler {
   Promise<Unit> promise_;
   DialogId dialog_id_;
@@ -15177,6 +15204,59 @@ void MessagesManager::on_delete_dialog_filter(DialogFilterId dialog_filter_id, S
   promise.set_value(Unit());
 }
 
+void MessagesManager::reorder_dialog_filters(vector<DialogFilterId> dialog_filter_ids, Promise<Unit> &&promise) {
+  CHECK(!td_->auth_manager_->is_bot());
+
+  for (auto dialog_filter_id : dialog_filter_ids) {
+    auto dialog_filter = get_dialog_filter(dialog_filter_id);
+    if (dialog_filter == nullptr) {
+      return promise.set_error(Status::Error(6, "Chat filter not found"));
+    }
+  }
+  std::unordered_set<DialogFilterId, DialogFilterIdHash> new_dialog_filter_ids_set(dialog_filter_ids.begin(),
+                                                                                   dialog_filter_ids.end());
+  if (new_dialog_filter_ids_set.size() != dialog_filter_ids.size()) {
+    return promise.set_error(Status::Error(400, "Duplicate chat filters in the new list"));
+  }
+
+  auto old_dialog_filter_ids = transform(dialog_filters_, [](auto &filter) { return filter->dialog_filter_id; });
+  if (old_dialog_filter_ids == dialog_filter_ids) {
+    return promise.set_value(Unit());
+  }
+  LOG(INFO) << "Reorder chat filters from " << old_dialog_filter_ids << " to " << dialog_filter_ids;
+
+  if (dialog_filter_ids.size() != old_dialog_filter_ids.size()) {
+    for (auto dialog_filter_id : old_dialog_filter_ids) {
+      if (!td::contains(dialog_filter_ids, dialog_filter_id)) {
+        dialog_filter_ids.push_back(dialog_filter_id);
+      }
+    }
+    CHECK(dialog_filter_ids.size() == old_dialog_filter_ids.size());
+  }
+  if (old_dialog_filter_ids == dialog_filter_ids) {
+    return promise.set_value(Unit());
+  }
+
+  CHECK(dialog_filter_ids.size() == dialog_filters_.size());
+  for (size_t i = 0; i < dialog_filters_.size(); i++) {
+    for (size_t j = i; j < dialog_filters_.size(); j++) {
+      if (dialog_filters_[j]->dialog_filter_id == dialog_filter_ids[i]) {
+        if (i != j) {
+          std::swap(dialog_filters_[i], dialog_filters_[j]);
+        }
+        break;
+      }
+    }
+    CHECK(dialog_filters_[i]->dialog_filter_id == dialog_filter_ids[i]);
+  }
+  send_update_chat_filters(false);
+
+  // TODO logevent
+  // TODO SequenceDispatcher
+  td_->create_handler<ReorderDialogFiltersQuery>(std::move(promise))->send(dialog_filter_ids);
+  return promise.set_value(Unit());
+}
+
 Status MessagesManager::delete_dialog_reply_markup(DialogId dialog_id, MessageId message_id) {
   if (td_->auth_manager_->is_bot()) {
     return Status::Error(6, "Bots can't delete chat reply markup");
@@ -15483,8 +15563,7 @@ Status MessagesManager::set_pinned_dialogs(FolderId folder_id, vector<DialogId>
   if (pinned_dialog_ids == dialog_ids) {
     return Status::OK();
   }
-  LOG(INFO) << "Reorder pinned chats order in " << folder_id << " from " << format::as_array(pinned_dialog_ids)
-            << " to " << format::as_array(dialog_ids);
+  LOG(INFO) << "Reorder pinned chats in " << folder_id << " from " << pinned_dialog_ids << " to " << dialog_ids;
 
   auto server_old_dialog_ids = remove_secret_chat_dialog_ids(pinned_dialog_ids);
   auto server_new_dialog_ids = remove_secret_chat_dialog_ids(dialog_ids);

td/telegram/MessagesManager.h

@@ -558,6 +558,8 @@ class MessagesManager : public Actor {
 
   void delete_dialog_filter(DialogFilterId dialog_filter_id, Promise<Unit> &&promise);
 
+  void reorder_dialog_filters(vector<DialogFilterId> dialog_filter_ids, Promise<Unit> &&promise);
+
   Status delete_dialog_reply_markup(DialogId dialog_id, MessageId message_id) TD_WARN_UNUSED_RESULT;
 
   Status set_dialog_draft_message(DialogId dialog_id,

td/telegram/Td.cpp

@@ -5906,6 +5906,13 @@ void Td::on_request(uint64 id, const td_api::deleteChatFilter &request) {
   messages_manager_->delete_dialog_filter(DialogFilterId(request.chat_filter_id_), std::move(promise));
 }
 
+void Td::on_request(uint64 id, const td_api::reorderChatFilters &request) {
+  CHECK_IS_USER();
+  CREATE_OK_REQUEST_PROMISE();
+  messages_manager_->reorder_dialog_filters(
+      transform(request.chat_filter_ids_, [](int32 id) { return DialogFilterId(id); }), std::move(promise));
+}
+
 void Td::on_request(uint64 id, td_api::setChatTitle &request) {
   CLEAN_INPUT_STRING(request.title_);
   CREATE_OK_REQUEST_PROMISE();

td/telegram/Td.h

@@ -683,6 +683,8 @@ class Td final : public NetQueryCallback {
 
   void on_request(uint64 id, const td_api::deleteChatFilter &request);
 
+  void on_request(uint64 id, const td_api::reorderChatFilters &request);
+
   void on_request(uint64 id, td_api::setChatTitle &request);
 
   void on_request(uint64 id, const td_api::setChatPhoto &request);

td/telegram/cli.cpp

@@ -471,6 +471,11 @@ class CliClient final : public Actor {
     return to_integer<int32>(trim(str));
   }
 
+  vector<int32> as_chat_filter_ids(Slice chat_filter_ids) const {
+    return transform(full_split(trim(chat_filter_ids), get_delimiter(chat_filter_ids)),
+                     [this](Slice str) { return as_chat_filter_id(str); });
+  }
+
   static td_api::object_ptr<td_api::ChatList> as_chat_list(string chat_list) {
     if (!chat_list.empty() && chat_list.back() == 'a') {
       return td_api::make_object<td_api::chatListArchive>();
@@ -3517,6 +3522,8 @@ class CliClient final : public Actor {
           td_api::make_object<td_api::editChatFilter>(as_chat_filter_id(chat_filter_id), as_chat_filter(filter)));
     } else if (op == "dcf") {
       send_request(td_api::make_object<td_api::deleteChatFilter>(as_chat_filter_id(args)));
+    } else if (op == "rcf") {
+      send_request(td_api::make_object<td_api::reorderChatFilters>(as_chat_filter_ids(args)));
     } else if (op == "sct") {
       string chat_id;
       string title;