tdlight-team/tdlight
tdlight-team/tdlight
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Move get_chat_filter_object and load_dialog_filter to DialogFilterManager.

Browse Source
This commit is contained in:
levlam 2023-03-27 14:09:55 +03:00
parent 0ff733edad
commit 2ef970307b
5 changed files with 245 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

205
td/telegram/DialogFilterManager.cpp
View File

@ -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,
mpas.get_promise());
load_dialog_filter(recommended_dialog_filter.dialog_filter.get(), false, 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()),
recommended_dialog_filter.description);
get_chat_filter_object(recommended_dialog_filter.dialog_filter.get()), 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

19
td/telegram/DialogFilterManager.h
View File

@ -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_;

225
td/telegram/MessagesManager.cpp
View File

@ -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),
std::move(promise));
td_->dialog_filter_manager_->load_dialog_filter_dialogs(dialog_filter->get_dialog_filter_id(),
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) {

26
td/telegram/MessagesManager.h
View File

@ -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;

4
td/telegram/Td.cpp
View File

@ -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: