Move get_chat_filter_object and load_dialog_filter to DialogFilterManager.

td/telegram/DialogFilterManager.cpp

@@ -7,6 +7,7 @@
 #include "td/telegram/DialogFilterManager.h"
 
 #include "td/telegram/AuthManager.h"
+#include "td/telegram/ContactsManager.h"
 #include "td/telegram/DialogFilter.h"
 #include "td/telegram/Global.h"
 #include "td/telegram/MessagesManager.h"
@@ -19,6 +20,46 @@
 
 namespace td {
 
+class GetDialogsQuery final : public Td::ResultHandler {
+  Promise<Unit> promise_;
+  bool is_single_ = false;
+
+ public:
+  explicit GetDialogsQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
+  }
+
+  void send(vector<InputDialogId> input_dialog_ids) {
+    CHECK(!input_dialog_ids.empty());
+    CHECK(input_dialog_ids.size() <= 100);
+    is_single_ = input_dialog_ids.size() == 1;
+    auto input_dialog_peers = InputDialogId::get_input_dialog_peers(input_dialog_ids);
+    CHECK(input_dialog_peers.size() == input_dialog_ids.size());
+    send_query(G()->net_query_creator().create(telegram_api::messages_getPeerDialogs(std::move(input_dialog_peers))));
+  }
+
+  void on_result(BufferSlice packet) final {
+    auto result_ptr = fetch_result<telegram_api::messages_getPeerDialogs>(packet);
+    if (result_ptr.is_error()) {
+      return on_error(result_ptr.move_as_error());
+    }
+
+    auto result = result_ptr.move_as_ok();
+    LOG(INFO) << "Receive result for GetDialogsQuery: " << to_string(result);
+
+    td_->contacts_manager_->on_get_users(std::move(result->users_), "GetDialogsQuery");
+    td_->contacts_manager_->on_get_chats(std::move(result->chats_), "GetDialogsQuery");
+    td_->messages_manager_->on_get_dialogs(FolderId(), std::move(result->dialogs_), -1, std::move(result->messages_),
+                                           std::move(promise_));
+  }
+
+  void on_error(Status status) final {
+    if (is_single_ && status.code() == 400) {
+      return promise_.set_value(Unit());
+    }
+    promise_.set_error(std::move(status));
+  }
+};
+
 class GetSuggestedDialogFiltersQuery final : public Td::ResultHandler {
   Promise<vector<tl_object_ptr<telegram_api::dialogFilterSuggested>>> promise_;
 
@@ -61,6 +102,44 @@ bool DialogFilterManager::is_recommended_dialog_filter(const DialogFilter *dialo
   return false;
 }
 
+td_api::object_ptr<td_api::chatFilter> DialogFilterManager::get_chat_filter_object(DialogFilterId dialog_filter_id) {
+  CHECK(!td_->auth_manager_->is_bot());
+  auto dialog_filter = td_->messages_manager_->get_dialog_filter(dialog_filter_id);
+  if (dialog_filter == nullptr) {
+    return nullptr;
+  }
+
+  return get_chat_filter_object(dialog_filter);
+}
+
+td_api::object_ptr<td_api::chatFilter> DialogFilterManager::get_chat_filter_object(const DialogFilter *dialog_filter) {
+  DialogFilterId dialog_filter_id = dialog_filter->get_dialog_filter_id();
+
+  vector<DialogId> left_dialog_ids;
+  vector<DialogId> unknown_dialog_ids;
+  dialog_filter->for_each_dialog([&](const InputDialogId &input_dialog_id) {
+    auto dialog_id = input_dialog_id.get_dialog_id();
+    if (td_->messages_manager_->is_dialog_in_dialog_list(dialog_id)) {
+      return;
+    }
+    if (td_->messages_manager_->have_dialog(dialog_id)) {
+      LOG(INFO) << "Skip nonjoined " << dialog_id << " from " << dialog_filter_id;
+      unknown_dialog_ids.push_back(dialog_id);
+      left_dialog_ids.push_back(dialog_id);
+    } else {
+      LOG(ERROR) << "Can't find " << dialog_id << " from " << dialog_filter_id;
+      unknown_dialog_ids.push_back(dialog_id);
+    }
+  });
+
+  auto result = dialog_filter->get_chat_filter_object(unknown_dialog_ids);
+
+  if (dialog_filter_id.is_valid()) {
+    delete_dialogs_from_filter(dialog_filter, std::move(left_dialog_ids), "get_chat_filter_object");
+  }
+  return result;
+}
+
 void DialogFilterManager::get_recommended_dialog_filters(
     Promise<td_api::object_ptr<td_api::recommendedChatFilters>> &&promise) {
   CHECK(!td_->auth_manager_->is_bot());
@@ -92,8 +171,7 @@ void DialogFilterManager::on_get_recommended_dialog_filters(
     recommended_dialog_filter.dialog_filter =
         DialogFilter::get_dialog_filter(std::move(suggested_filter->filter_), false);
     CHECK(recommended_dialog_filter.dialog_filter != nullptr);
-    td_->messages_manager_->load_dialog_filter(recommended_dialog_filter.dialog_filter.get(), false,
+    load_dialog_filter(recommended_dialog_filter.dialog_filter.get(), false, mpas.get_promise());
-                                               mpas.get_promise());
 
     recommended_dialog_filter.description = std::move(suggested_filter->description_);
     filters.push_back(std::move(recommended_dialog_filter));
@@ -118,11 +196,130 @@ void DialogFilterManager::on_load_recommended_dialog_filters(
 
   auto chat_filters = transform(filters, [this](const RecommendedDialogFilter &recommended_dialog_filter) {
     return td_api::make_object<td_api::recommendedChatFilter>(
-        td_->messages_manager_->get_chat_filter_object(recommended_dialog_filter.dialog_filter.get()),
+        get_chat_filter_object(recommended_dialog_filter.dialog_filter.get()), recommended_dialog_filter.description);
-        recommended_dialog_filter.description);
   });
   recommended_dialog_filters_ = std::move(filters);
   promise.set_value(td_api::make_object<td_api::recommendedChatFilters>(std::move(chat_filters)));
 }
 
+void DialogFilterManager::load_dialog_filter(DialogFilterId dialog_filter_id, bool force, Promise<Unit> &&promise) {
+  CHECK(!td_->auth_manager_->is_bot());
+  if (!dialog_filter_id.is_valid()) {
+    return promise.set_error(Status::Error(400, "Invalid chat filter identifier specified"));
+  }
+
+  auto dialog_filter = td_->messages_manager_->get_dialog_filter(dialog_filter_id);
+  if (dialog_filter == nullptr) {
+    return promise.set_value(Unit());
+  }
+
+  load_dialog_filter(dialog_filter, force, std::move(promise));
+}
+
+void DialogFilterManager::load_dialog_filter(const DialogFilter *dialog_filter, bool force, Promise<Unit> &&promise) {
+  CHECK(!td_->auth_manager_->is_bot());
+  vector<InputDialogId> needed_dialog_ids;
+  dialog_filter->for_each_dialog([&](const InputDialogId &input_dialog_id) {
+    if (!td_->messages_manager_->have_dialog(input_dialog_id.get_dialog_id())) {
+      needed_dialog_ids.push_back(input_dialog_id);
+    }
+  });
+
+  vector<InputDialogId> input_dialog_ids;
+  for (const auto &input_dialog_id : needed_dialog_ids) {
+    auto dialog_id = input_dialog_id.get_dialog_id();
+    // TODO load dialogs asynchronously
+    if (!td_->messages_manager_->have_dialog_force(dialog_id, "load_dialog_filter")) {
+      if (dialog_id.get_type() == DialogType::SecretChat) {
+        if (td_->messages_manager_->have_dialog_info_force(dialog_id)) {
+          td_->messages_manager_->force_create_dialog(dialog_id, "load_dialog_filter");
+        }
+      } else {
+        input_dialog_ids.push_back(input_dialog_id);
+      }
+    }
+  }
+
+  if (!input_dialog_ids.empty() && !force) {
+    return load_dialog_filter_dialogs(dialog_filter->get_dialog_filter_id(), std::move(input_dialog_ids),
+                                      std::move(promise));
+  }
+
+  promise.set_value(Unit());
+}
+
+void DialogFilterManager::load_dialog_filter_dialogs(DialogFilterId dialog_filter_id,
+                                                     vector<InputDialogId> &&input_dialog_ids,
+                                                     Promise<Unit> &&promise) {
+  const size_t MAX_SLICE_SIZE = 100;  // server side limit
+  MultiPromiseActorSafe mpas{"GetFilterDialogsOnServerMultiPromiseActor"};
+  mpas.add_promise(std::move(promise));
+  auto lock = mpas.get_promise();
+
+  for (size_t i = 0; i < input_dialog_ids.size(); i += MAX_SLICE_SIZE) {
+    auto end_i = i + MAX_SLICE_SIZE;
+    auto end = end_i < input_dialog_ids.size() ? input_dialog_ids.begin() + end_i : input_dialog_ids.end();
+    vector<InputDialogId> slice_input_dialog_ids = {input_dialog_ids.begin() + i, end};
+    auto query_promise = PromiseCreator::lambda([actor_id = actor_id(this), dialog_filter_id,
+                                                 dialog_ids = InputDialogId::get_dialog_ids(slice_input_dialog_ids),
+                                                 promise = mpas.get_promise()](Result<Unit> &&result) mutable {
+      if (result.is_error()) {
+        return promise.set_error(result.move_as_error());
+      }
+      send_closure(actor_id, &DialogFilterManager::on_load_dialog_filter_dialogs, dialog_filter_id,
+                   std::move(dialog_ids), std::move(promise));
+    });
+    td_->create_handler<GetDialogsQuery>(std::move(query_promise))->send(std::move(slice_input_dialog_ids));
+  }
+
+  lock.set_value(Unit());
+}
+
+void DialogFilterManager::on_load_dialog_filter_dialogs(DialogFilterId dialog_filter_id, vector<DialogId> &&dialog_ids,
+                                                        Promise<Unit> &&promise) {
+  TRY_STATUS_PROMISE(promise, G()->close_status());
+
+  td::remove_if(dialog_ids, [messages_manager = td_->messages_manager_.get()](DialogId dialog_id) {
+    return messages_manager->have_dialog_force(dialog_id, "on_load_dialog_filter_dialogs");
+  });
+  if (dialog_ids.empty()) {
+    LOG(INFO) << "All chats from " << dialog_filter_id << " were loaded";
+    return promise.set_value(Unit());
+  }
+
+  LOG(INFO) << "Failed to load chats " << dialog_ids << " from " << dialog_filter_id;
+
+  auto old_dialog_filter = td_->messages_manager_->get_dialog_filter(dialog_filter_id);
+  if (old_dialog_filter == nullptr) {
+    return promise.set_value(Unit());
+  }
+  //TODO CHECK(is_update_chat_filters_sent_);
+
+  delete_dialogs_from_filter(old_dialog_filter, std::move(dialog_ids), "on_load_dialog_filter_dialogs");
+
+  promise.set_value(Unit());
+}
+
+void DialogFilterManager::delete_dialogs_from_filter(const DialogFilter *dialog_filter, vector<DialogId> &&dialog_ids,
+                                                     const char *source) {
+  if (dialog_ids.empty()) {
+    return;
+  }
+
+  auto new_dialog_filter = td::make_unique<DialogFilter>(*dialog_filter);
+  for (auto dialog_id : dialog_ids) {
+    new_dialog_filter->remove_dialog_id(dialog_id);
+  }
+  if (new_dialog_filter->is_empty(false)) {
+    td_->messages_manager_->delete_dialog_filter(dialog_filter->get_dialog_filter_id(), Promise<Unit>());
+    return;
+  }
+  CHECK(new_dialog_filter->check_limits().is_ok());
+
+  if (*new_dialog_filter != *dialog_filter) {
+    LOG(INFO) << "Update " << *dialog_filter << " to " << *new_dialog_filter;
+    td_->messages_manager_->do_edit_dialog_filter(std::move(new_dialog_filter), "delete_dialogs_from_filter");
+  }
+}
+
 }  // namespace td

td/telegram/DialogFilterManager.h

@@ -6,6 +6,9 @@
 //
 #pragma once
 
+#include "td/telegram/DialogFilterId.h"
+#include "td/telegram/DialogId.h"
+#include "td/telegram/InputDialogId.h"
 #include "td/telegram/td_api.h"
 #include "td/telegram/telegram_api.h"
 
@@ -24,10 +27,19 @@ class DialogFilterManager final : public Actor {
  public:
   DialogFilterManager(Td *td, ActorShared<> parent);
 
+  td_api::object_ptr<td_api::chatFilter> get_chat_filter_object(DialogFilterId dialog_filter_id);
+
+  td_api::object_ptr<td_api::chatFilter> get_chat_filter_object(const DialogFilter *dialog_filter);
+
   bool is_recommended_dialog_filter(const DialogFilter *dialog_filter);
 
   void get_recommended_dialog_filters(Promise<td_api::object_ptr<td_api::recommendedChatFilters>> &&promise);
 
+  void load_dialog_filter(DialogFilterId dialog_filter_id, bool force, Promise<Unit> &&promise);
+
+  void load_dialog_filter_dialogs(DialogFilterId dialog_filter_id, vector<InputDialogId> &&input_dialog_ids,
+                                  Promise<Unit> &&promise);
+
  private:
   void tear_down() final;
 
@@ -43,6 +55,13 @@ class DialogFilterManager final : public Actor {
   void on_load_recommended_dialog_filters(Result<Unit> &&result, vector<RecommendedDialogFilter> &&filters,
                                           Promise<td_api::object_ptr<td_api::recommendedChatFilters>> &&promise);
 
+  void load_dialog_filter(const DialogFilter *dialog_filter, bool force, Promise<Unit> &&promise);
+
+  void on_load_dialog_filter_dialogs(DialogFilterId dialog_filter_id, vector<DialogId> &&dialog_ids,
+                                     Promise<Unit> &&promise);
+
+  void delete_dialogs_from_filter(const DialogFilter *dialog_filter, vector<DialogId> &&dialog_ids, const char *source);
+
   vector<RecommendedDialogFilter> recommended_dialog_filters_;
 
   Td *td_;

td/telegram/MessagesManager.cpp

@@ -277,46 +277,6 @@ class GetDialogQuery final : public Td::ResultHandler {
   }
 };
 
-class GetDialogsQuery final : public Td::ResultHandler {
-  Promise<Unit> promise_;
-  bool is_single_ = false;
-
- public:
-  explicit GetDialogsQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
-  }
-
-  void send(vector<InputDialogId> input_dialog_ids) {
-    CHECK(!input_dialog_ids.empty());
-    CHECK(input_dialog_ids.size() <= 100);
-    is_single_ = input_dialog_ids.size() == 1;
-    auto input_dialog_peers = InputDialogId::get_input_dialog_peers(input_dialog_ids);
-    CHECK(input_dialog_peers.size() == input_dialog_ids.size());
-    send_query(G()->net_query_creator().create(telegram_api::messages_getPeerDialogs(std::move(input_dialog_peers))));
-  }
-
-  void on_result(BufferSlice packet) final {
-    auto result_ptr = fetch_result<telegram_api::messages_getPeerDialogs>(packet);
-    if (result_ptr.is_error()) {
-      return on_error(result_ptr.move_as_error());
-    }
-
-    auto result = result_ptr.move_as_ok();
-    LOG(INFO) << "Receive result for GetDialogsQuery: " << to_string(result);
-
-    td_->contacts_manager_->on_get_users(std::move(result->users_), "GetDialogsQuery");
-    td_->contacts_manager_->on_get_chats(std::move(result->chats_), "GetDialogsQuery");
-    td_->messages_manager_->on_get_dialogs(FolderId(), std::move(result->dialogs_), -1, std::move(result->messages_),
-                                           std::move(promise_));
-  }
-
-  void on_error(Status status) final {
-    if (is_single_ && status.code() == 400) {
-      return promise_.set_value(Unit());
-    }
-    promise_.set_error(std::move(status));
-  }
-};
-
 class GetPinnedDialogsQuery final : public Td::ResultHandler {
   FolderId folder_id_;
   Promise<Unit> promise_;
@@ -16973,135 +16933,6 @@ bool MessagesManager::load_dialog(DialogId dialog_id, int left_tries, Promise<Un
   return true;
 }
 
-void MessagesManager::load_dialog_filter_dialogs(DialogFilterId dialog_filter_id,
-                                                 vector<InputDialogId> &&input_dialog_ids, Promise<Unit> &&promise) {
-  const size_t MAX_SLICE_SIZE = 100;  // server side limit
-  MultiPromiseActorSafe mpas{"GetFilterDialogsOnServerMultiPromiseActor"};
-  mpas.add_promise(std::move(promise));
-  auto lock = mpas.get_promise();
-
-  for (size_t i = 0; i < input_dialog_ids.size(); i += MAX_SLICE_SIZE) {
-    auto end_i = i + MAX_SLICE_SIZE;
-    auto end = end_i < input_dialog_ids.size() ? input_dialog_ids.begin() + end_i : input_dialog_ids.end();
-    vector<InputDialogId> slice_input_dialog_ids = {input_dialog_ids.begin() + i, end};
-    auto query_promise = PromiseCreator::lambda([actor_id = actor_id(this), dialog_filter_id,
-                                                 dialog_ids = InputDialogId::get_dialog_ids(slice_input_dialog_ids),
-                                                 promise = mpas.get_promise()](Result<Unit> &&result) mutable {
-      if (result.is_error()) {
-        return promise.set_error(result.move_as_error());
-      }
-      send_closure(actor_id, &MessagesManager::on_load_dialog_filter_dialogs, dialog_filter_id, std::move(dialog_ids),
-                   std::move(promise));
-    });
-    td_->create_handler<GetDialogsQuery>(std::move(query_promise))->send(std::move(slice_input_dialog_ids));
-  }
-
-  lock.set_value(Unit());
-}
-
-void MessagesManager::on_load_dialog_filter_dialogs(DialogFilterId dialog_filter_id, vector<DialogId> &&dialog_ids,
-                                                    Promise<Unit> &&promise) {
-  TRY_STATUS_PROMISE(promise, G()->close_status());
-
-  td::remove_if(dialog_ids,
-                [this](DialogId dialog_id) { return have_dialog_force(dialog_id, "on_load_dialog_filter_dialogs"); });
-  if (dialog_ids.empty()) {
-    LOG(INFO) << "All chats from " << dialog_filter_id << " were loaded";
-    return promise.set_value(Unit());
-  }
-
-  LOG(INFO) << "Failed to load chats " << dialog_ids << " from " << dialog_filter_id;
-
-  auto old_dialog_filter = get_dialog_filter(dialog_filter_id);
-  if (old_dialog_filter == nullptr) {
-    return promise.set_value(Unit());
-  }
-  CHECK(is_update_chat_filters_sent_);
-
-  delete_dialogs_from_filter(old_dialog_filter, std::move(dialog_ids), "on_load_dialog_filter_dialogs");
-
-  promise.set_value(Unit());
-}
-
-void MessagesManager::load_dialog_filter(DialogFilterId dialog_filter_id, bool force, Promise<Unit> &&promise) {
-  CHECK(!td_->auth_manager_->is_bot());
-  if (!dialog_filter_id.is_valid()) {
-    return promise.set_error(Status::Error(400, "Invalid chat filter identifier specified"));
-  }
-
-  auto dialog_filter = get_dialog_filter(dialog_filter_id);
-  if (dialog_filter == nullptr) {
-    return promise.set_value(Unit());
-  }
-
-  load_dialog_filter(dialog_filter, force, std::move(promise));
-}
-
-void MessagesManager::load_dialog_filter(const DialogFilter *dialog_filter, bool force, Promise<Unit> &&promise) {
-  CHECK(!td_->auth_manager_->is_bot());
-  vector<InputDialogId> needed_dialog_ids;
-  dialog_filter->for_each_dialog([&](const InputDialogId &input_dialog_id) {
-    if (!have_dialog(input_dialog_id.get_dialog_id())) {
-      needed_dialog_ids.push_back(input_dialog_id);
-    }
-  });
-
-  vector<InputDialogId> input_dialog_ids;
-  for (const auto &input_dialog_id : needed_dialog_ids) {
-    auto dialog_id = input_dialog_id.get_dialog_id();
-    // TODO load dialogs asynchronously
-    if (!have_dialog_force(dialog_id, "load_dialog_filter")) {
-      if (dialog_id.get_type() == DialogType::SecretChat) {
-        if (have_dialog_info_force(dialog_id)) {
-          force_create_dialog(dialog_id, "load_dialog_filter");
-        }
-      } else {
-        input_dialog_ids.push_back(input_dialog_id);
-      }
-    }
-  }
-
-  if (!input_dialog_ids.empty() && !force) {
-    return load_dialog_filter_dialogs(dialog_filter->get_dialog_filter_id(), std::move(input_dialog_ids),
-                                      std::move(promise));
-  }
-
-  promise.set_value(Unit());
-}
-
-void MessagesManager::delete_dialogs_from_filter(const DialogFilter *dialog_filter, vector<DialogId> &&dialog_ids,
-                                                 const char *source) {
-  if (dialog_ids.empty()) {
-    return;
-  }
-
-  auto new_dialog_filter = td::make_unique<DialogFilter>(*dialog_filter);
-  for (auto dialog_id : dialog_ids) {
-    new_dialog_filter->remove_dialog_id(dialog_id);
-  }
-  if (new_dialog_filter->is_empty(false)) {
-    int32 position = delete_dialog_filter(dialog_filter->get_dialog_filter_id(), "delete_dialogs_from_filter");
-    if (main_dialog_list_position_ > position) {
-      main_dialog_list_position_--;
-    }
-    save_dialog_filters();
-    send_update_chat_filters();
-
-    synchronize_dialog_filters();
-    return;
-  }
-  CHECK(new_dialog_filter->check_limits().is_ok());
-
-  if (*new_dialog_filter != *dialog_filter) {
-    LOG(INFO) << "Update " << *dialog_filter << " to " << *new_dialog_filter;
-    edit_dialog_filter(std::move(new_dialog_filter), source);
-    save_dialog_filters();
-    send_update_chat_filters();
-
-    synchronize_dialog_filters();
-  }
-}
-
 Result<DialogDate> MessagesManager::get_dialog_list_last_date(DialogListId dialog_list_id) {
   CHECK(!td_->auth_manager_->is_bot());
 
@@ -17186,8 +17017,8 @@ vector<DialogId> MessagesManager::get_dialogs(DialogListId dialog_list_id, Dialo
         promise.set_value(Unit());
         return result;
       } else {
-        load_dialog_filter_dialogs(dialog_filter->get_dialog_filter_id(), std::move(input_dialog_ids),
+        td_->dialog_filter_manager_->load_dialog_filter_dialogs(dialog_filter->get_dialog_filter_id(),
-                                   std::move(promise));
+                                                                std::move(input_dialog_ids), std::move(promise));
         return {};
       }
     }
@@ -19687,6 +19518,14 @@ void MessagesManager::edit_dialog_filter(DialogFilterId dialog_filter_id, td_api
   promise.set_value(std::move(chat_filter_info));
 }
 
+void MessagesManager::do_edit_dialog_filter(unique_ptr<DialogFilter> &&filter, const char *source) {
+  edit_dialog_filter(std::move(filter), source);
+  save_dialog_filters();
+  send_update_chat_filters();
+
+  synchronize_dialog_filters();
+}
+
 void MessagesManager::update_dialog_filter_on_server(unique_ptr<DialogFilter> &&dialog_filter) {
   CHECK(!td_->auth_manager_->is_bot());
   CHECK(dialog_filter != nullptr);
@@ -21990,44 +21829,6 @@ tl_object_ptr<td_api::chats> MessagesManager::get_chats_object(const std::pair<i
   return get_chats_object(dialog_ids.first, dialog_ids.second);
 }
 
-td_api::object_ptr<td_api::chatFilter> MessagesManager::get_chat_filter_object(DialogFilterId dialog_filter_id) {
-  CHECK(!td_->auth_manager_->is_bot());
-  auto dialog_filter = get_dialog_filter(dialog_filter_id);
-  if (dialog_filter == nullptr) {
-    return nullptr;
-  }
-
-  return get_chat_filter_object(dialog_filter);
-}
-
-td_api::object_ptr<td_api::chatFilter> MessagesManager::get_chat_filter_object(const DialogFilter *dialog_filter) {
-  DialogFilterId dialog_filter_id = dialog_filter->get_dialog_filter_id();
-
-  vector<DialogId> left_dialog_ids;
-  vector<DialogId> unknown_dialog_ids;
-  dialog_filter->for_each_dialog([&](const InputDialogId &input_dialog_id) {
-    auto dialog_id = input_dialog_id.get_dialog_id();
-    const Dialog *d = get_dialog(dialog_id);
-    if (d != nullptr) {
-      if (d->order == DEFAULT_ORDER) {
-        LOG(INFO) << "Skip nonjoined " << dialog_id << " from " << dialog_filter_id;
-        unknown_dialog_ids.push_back(dialog_id);
-        left_dialog_ids.push_back(dialog_id);
-      }
-    } else {
-      LOG(ERROR) << "Can't find " << dialog_id << " from " << dialog_filter_id;
-      unknown_dialog_ids.push_back(dialog_id);
-    }
-  });
-
-  auto result = dialog_filter->get_chat_filter_object(unknown_dialog_ids);
-
-  if (dialog_filter_id.is_valid()) {
-    delete_dialogs_from_filter(dialog_filter, std::move(left_dialog_ids), "get_chat_filter_object");
-  }
-  return result;
-}
-
 std::pair<bool, int32> MessagesManager::get_dialog_mute_until(DialogId dialog_id, const Dialog *d) const {
   CHECK(!td_->auth_manager_->is_bot());
   if (d == nullptr || !d->notification_settings.is_synchronized) {
@@ -38972,6 +38773,12 @@ bool MessagesManager::need_dialog_in_filter(const Dialog *d, const DialogFilter
       is_dialog_muted(d), d->server_unread_count + d->local_unread_count != 0 || d->is_marked_as_unread, d->folder_id);
 }
 
+bool MessagesManager::is_dialog_in_dialog_list(DialogId dialog_id) const {
+  CHECK(!td_->auth_manager_->is_bot());
+  const Dialog *d = get_dialog(dialog_id);
+  return d != nullptr && d->order != DEFAULT_ORDER;
+}
+
 bool MessagesManager::need_dialog_in_list(const Dialog *d, const DialogList &list) const {
   CHECK(!td_->auth_manager_->is_bot());
   if (d->order == DEFAULT_ORDER) {

td/telegram/MessagesManager.h

@@ -579,10 +579,6 @@ class MessagesManager final : public Actor {
 
   void load_dialogs(vector<DialogId> dialog_ids, Promise<vector<DialogId>> &&promise);
 
-  void load_dialog_filter(DialogFilterId dialog_filter_id, bool force, Promise<Unit> &&promise);
-
-  void load_dialog_filter(const DialogFilter *dialog_filter, bool force, Promise<Unit> &&promise);
-
   Result<DialogDate> get_dialog_list_last_date(DialogListId dialog_list_id);
 
   vector<DialogId> get_dialogs(DialogListId dialog_list_id, DialogDate offset, int32 limit, bool exact_limit,
@@ -669,12 +665,19 @@ class MessagesManager final : public Actor {
 
   InputDialogId get_input_dialog_id(DialogId dialog_id) const;
 
+  bool is_dialog_in_dialog_list(DialogId dialog_id) const;
+
+  DialogFilter *get_dialog_filter(DialogFilterId dialog_filter_id);
+  const DialogFilter *get_dialog_filter(DialogFilterId dialog_filter_id) const;
+
   void create_dialog_filter(td_api::object_ptr<td_api::chatFilter> filter,
                             Promise<td_api::object_ptr<td_api::chatFilterInfo>> &&promise);
 
   void edit_dialog_filter(DialogFilterId dialog_filter_id, td_api::object_ptr<td_api::chatFilter> filter,
                           Promise<td_api::object_ptr<td_api::chatFilterInfo>> &&promise);
 
+  void do_edit_dialog_filter(unique_ptr<DialogFilter> &&filter, const char *source);
+
   void delete_dialog_filter(DialogFilterId dialog_filter_id, Promise<Unit> &&promise);
 
   void reorder_dialog_filters(vector<DialogFilterId> dialog_filter_ids, int32 main_dialog_list_position,
@@ -748,10 +751,6 @@ class MessagesManager final : public Actor {
 
   static tl_object_ptr<td_api::chats> get_chats_object(const std::pair<int32, vector<DialogId>> &dialog_ids);
 
-  td_api::object_ptr<td_api::chatFilter> get_chat_filter_object(DialogFilterId dialog_filter_id);
-
-  td_api::object_ptr<td_api::chatFilter> get_chat_filter_object(const DialogFilter *dialog_filter);
-
   tl_object_ptr<td_api::messages> get_dialog_history(DialogId dialog_id, MessageId from_message_id, int32 offset,
                                                      int32 limit, int left_tries, bool only_local,
                                                      Promise<Unit> &&promise);
@@ -2838,14 +2837,6 @@ class MessagesManager final : public Actor {
   void update_dialogs_hints(const Dialog *d);
   void update_dialogs_hints_rating(const Dialog *d);
 
-  void load_dialog_filter_dialogs(DialogFilterId dialog_filter_id, vector<InputDialogId> &&input_dialog_ids,
-                                  Promise<Unit> &&promise);
-
-  void on_load_dialog_filter_dialogs(DialogFilterId dialog_filter_id, vector<DialogId> &&dialog_ids,
-                                     Promise<Unit> &&promise);
-
-  void delete_dialogs_from_filter(const DialogFilter *dialog_filter, vector<DialogId> &&dialog_ids, const char *source);
-
   Result<unique_ptr<DialogFilter>> create_dialog_filter(DialogFilterId dialog_filter_id,
                                                         td_api::object_ptr<td_api::chatFilter> filter);
 
@@ -2872,9 +2863,6 @@ class MessagesManager final : public Actor {
 
   const DialogFilter *get_server_dialog_filter(DialogFilterId dialog_filter_id) const;
 
-  DialogFilter *get_dialog_filter(DialogFilterId dialog_filter_id);
-  const DialogFilter *get_dialog_filter(DialogFilterId dialog_filter_id) const;
-
   int32 get_server_main_dialog_list_position() const;
 
   vector<FolderId> get_dialog_list_folder_ids(const DialogList &list) const;

td/telegram/Td.cpp

@@ -731,11 +731,11 @@ class GetChatFilterRequest final : public RequestActor<> {
   DialogFilterId dialog_filter_id_;
 
   void do_run(Promise<Unit> &&promise) final {
-    td_->messages_manager_->load_dialog_filter(dialog_filter_id_, get_tries() < 2, std::move(promise));
+    td_->dialog_filter_manager_->load_dialog_filter(dialog_filter_id_, get_tries() < 2, std::move(promise));
   }
 
   void do_send_result() final {
-    send_result(td_->messages_manager_->get_chat_filter_object(dialog_filter_id_));
+    send_result(td_->dialog_filter_manager_->get_chat_filter_object(dialog_filter_id_));
   }
 
  public: