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

Use request promise in getBlockedMessageSenders.

Browse Source
This commit is contained in:
levlam 2021-10-09 22:05:23 +03:00
parent 564521453f
commit 628a490e2a
3 changed files with 36 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
td/telegram/MessagesManager.cpp
View File

@ -900,19 +900,18 @@ class GetCommonDialogsQuery final : public Td::ResultHandler {
}; };
class GetBlockedDialogsQuery final : public Td::ResultHandler { class GetBlockedDialogsQuery final : public Td::ResultHandler {
Promise<Unit> promise_; Promise<td_api::object_ptr<td_api::messageSenders>> promise_;
int32 offset_; int32 offset_;
int32 limit_; int32 limit_;
int64 random_id_;
public: public:
explicit GetBlockedDialogsQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) { explicit GetBlockedDialogsQuery(Promise<td_api::object_ptr<td_api::messageSenders>> &&promise)
: promise_(std::move(promise)) {
} }
void send(int32 offset, int32 limit, int64 random_id) { void send(int32 offset, int32 limit) {
offset_ = offset; offset_ = offset;
limit_ = limit; limit_ = limit;
random_id_ = random_id;
send_query(G()->net_query_creator().create(telegram_api::contacts_getBlocked(offset, limit))); send_query(G()->net_query_creator().create(telegram_api::contacts_getBlocked(offset, limit)));
} }
@ -932,9 +931,9 @@ class GetBlockedDialogsQuery final : public Td::ResultHandler {
td->contacts_manager_->on_get_users(std::move(blocked_peers->users_), "GetBlockedDialogsQuery"); td->contacts_manager_->on_get_users(std::move(blocked_peers->users_), "GetBlockedDialogsQuery");
td->contacts_manager_->on_get_chats(std::move(blocked_peers->chats_), "GetBlockedDialogsQuery"); td->contacts_manager_->on_get_chats(std::move(blocked_peers->chats_), "GetBlockedDialogsQuery");
td->messages_manager_->on_get_blocked_dialogs(offset_, limit_, random_id_, td->messages_manager_->on_get_blocked_dialogs(offset_, limit_,
narrow_cast<int32>(blocked_peers->blocked_.size()), narrow_cast<int32>(blocked_peers->blocked_.size()),
std::move(blocked_peers->blocked_)); std::move(blocked_peers->blocked_), std::move(promise_));
break; break;
} }
case telegram_api::contacts_blockedSlice::ID: { case telegram_api::contacts_blockedSlice::ID: {
@ -942,19 +941,16 @@ class GetBlockedDialogsQuery final : public Td::ResultHandler {
td->contacts_manager_->on_get_users(std::move(blocked_peers->users_), "GetBlockedDialogsQuery"); td->contacts_manager_->on_get_users(std::move(blocked_peers->users_), "GetBlockedDialogsQuery");
td->contacts_manager_->on_get_chats(std::move(blocked_peers->chats_), "GetBlockedDialogsQuery"); td->contacts_manager_->on_get_chats(std::move(blocked_peers->chats_), "GetBlockedDialogsQuery");
td->messages_manager_->on_get_blocked_dialogs(offset_, limit_, random_id_, blocked_peers->count_, td->messages_manager_->on_get_blocked_dialogs(offset_, limit_, blocked_peers->count_,
std::move(blocked_peers->blocked_)); std::move(blocked_peers->blocked_), std::move(promise_));
break; break;
} }
default: default:
UNREACHABLE(); UNREACHABLE();
} }
promise_.set_value(Unit());
} }
void on_error(uint64 id, Status status) final { void on_error(uint64 id, Status status) final {
td->messages_manager_->on_failed_get_blocked_dialogs(random_id_);
promise_.set_error(std::move(status)); promise_.set_error(std::move(status));
} }
}; };
@ -16724,78 +16720,54 @@ void MessagesManager::block_message_sender_from_replies_on_server(MessageId mess
->send(message_id, delete_message, delete_all_messages, report_spam); ->send(message_id, delete_message, delete_all_messages, report_spam);
} }
std::pair<int32, vector<DialogId>> MessagesManager::get_blocked_dialogs(int32 offset, int32 limit, int64 &random_id, void MessagesManager::get_blocked_dialogs(int32 offset, int32 limit,
Promise<Unit> &&promise) { Promise<td_api::object_ptr<td_api::messageSenders>> &&promise) {
LOG(INFO) << "Get blocked chats with offset = " << offset << " and limit = " << limit;
if (random_id != 0) {
// request has already been sent before
auto it = found_blocked_dialogs_.find(random_id);
CHECK(it != found_blocked_dialogs_.end());
auto result = std::move(it->second);
found_blocked_dialogs_.erase(it);
promise.set_value(Unit());
return result;
}
if (offset < 0) { if (offset < 0) {
promise.set_error(Status::Error(400, "Parameter offset must be non-negative")); return promise.set_error(Status::Error(400, "Parameter offset must be non-negative"));
return {};
} }
if (limit <= 0) { if (limit <= 0) {
promise.set_error(Status::Error(400, "Parameter limit must be positive")); return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
return {};
} }
do { td_->create_handler<GetBlockedDialogsQuery>(std::move(promise))->send(offset, limit);
random_id = Random::secure_int64();
} while (random_id == 0 || found_blocked_dialogs_.find(random_id) != found_blocked_dialogs_.end());
found_blocked_dialogs_[random_id]; // reserve place for result
td_->create_handler<GetBlockedDialogsQuery>(std::move(promise))->send(offset, limit, random_id);
return {};
} }
void MessagesManager::on_get_blocked_dialogs(int32 offset, int32 limit, int64 random_id, int32 total_count, void MessagesManager::on_get_blocked_dialogs(int32 offset, int32 limit, int32 total_count,
vector<tl_object_ptr<telegram_api::peerBlocked>> &&blocked_peers) { vector<tl_object_ptr<telegram_api::peerBlocked>> &&blocked_peers,
Promise<td_api::object_ptr<td_api::messageSenders>> &&promise) {
LOG(INFO) << "Receive " << blocked_peers.size() << " blocked chats from offset " << offset << " out of " LOG(INFO) << "Receive " << blocked_peers.size() << " blocked chats from offset " << offset << " out of "
<< total_count; << total_count;
auto it = found_blocked_dialogs_.find(random_id); vector<DialogId> dialog_ids;
CHECK(it != found_blocked_dialogs_.end());
auto &result = it->second.second;
CHECK(result.empty());
for (auto &blocked_peer : blocked_peers) { for (auto &blocked_peer : blocked_peers) {
CHECK(blocked_peer != nullptr); CHECK(blocked_peer != nullptr);
DialogId dialog_id(blocked_peer->peer_id_); DialogId dialog_id(blocked_peer->peer_id_);
if (dialog_id.get_type() == DialogType::User) { if (dialog_id.get_type() == DialogType::User) {
if (td_->contacts_manager_->have_user(dialog_id.get_user_id())) { if (td_->contacts_manager_->have_user(dialog_id.get_user_id())) {
result.push_back(dialog_id); dialog_ids.push_back(dialog_id);
} else { } else {
LOG(ERROR) << "Have no info about " << dialog_id.get_user_id(); LOG(ERROR) << "Have no info about " << dialog_id.get_user_id();
} }
} else { } else {
if (have_dialog_info(dialog_id)) {
force_create_dialog(dialog_id, "on_get_blocked_dialogs"); force_create_dialog(dialog_id, "on_get_blocked_dialogs");
if (have_dialog(dialog_id)) { if (have_dialog(dialog_id)) {
result.push_back(dialog_id); dialog_ids.push_back(dialog_id);
}
} else { } else {
LOG(ERROR) << "Have no info about " << dialog_id; LOG(ERROR) << "Have no info about " << dialog_id;
} }
} }
} }
if (!result.empty() && offset + result.size() > static_cast<size_t>(total_count)) { if (!dialog_ids.empty() && offset + dialog_ids.size() > static_cast<size_t>(total_count)) {
LOG(ERROR) << "Fix total count of blocked chats from " << total_count << " to " << offset + result.size(); LOG(ERROR) << "Fix total count of blocked chats from " << total_count << " to " << offset + dialog_ids.size();
total_count = offset + narrow_cast<int32>(result.size()); total_count = offset + narrow_cast<int32>(dialog_ids.size());
} }
it->second.first = total_count;
}
void MessagesManager::on_failed_get_blocked_dialogs(int64 random_id) { auto senders = transform(dialog_ids, [this](DialogId dialog_id) {
auto it = found_blocked_dialogs_.find(random_id); return get_message_sender_object(dialog_id, "on_get_blocked_dialogs");
CHECK(it != found_blocked_dialogs_.end()); });
found_blocked_dialogs_.erase(it); promise.set_value(td_api::make_object<td_api::messageSenders>(total_count, std::move(senders)));
} }
bool MessagesManager::have_message_force(FullMessageId full_message_id, const char *source) { bool MessagesManager::have_message_force(FullMessageId full_message_id, const char *source) {

13
td/telegram/MessagesManager.h
View File

@ -546,13 +546,11 @@ class MessagesManager final : public Actor {
void block_message_sender_from_replies(MessageId message_id, bool delete_message, bool delete_all_messages, void block_message_sender_from_replies(MessageId message_id, bool delete_message, bool delete_all_messages,
bool report_spam, Promise<Unit> &&promise); bool report_spam, Promise<Unit> &&promise);
std::pair<int32, vector<DialogId>> get_blocked_dialogs(int32 offset, int32 limit, int64 &random_id, void get_blocked_dialogs(int32 offset, int32 limit, Promise<td_api::object_ptr<td_api::messageSenders>> &&promise);
Promise<Unit> &&promise);
void on_get_blocked_dialogs(int32 offset, int32 limit, int64 random_id, int32 total_count, void on_get_blocked_dialogs(int32 offset, int32 limit, int32 total_count,
vector<tl_object_ptr<telegram_api::peerBlocked>> &&blocked_peers); vector<tl_object_ptr<telegram_api::peerBlocked>> &&blocked_peers,
Promise<td_api::object_ptr<td_api::messageSenders>> &&promise);
void on_failed_get_blocked_dialogs(int64 random_id);
bool can_get_message_statistics(FullMessageId full_message_id); bool can_get_message_statistics(FullMessageId full_message_id);
@ -3275,9 +3273,6 @@ class MessagesManager final : public Actor {
}; };
std::unordered_map<UserId, CommonDialogs, UserIdHash> found_common_dialogs_; std::unordered_map<UserId, CommonDialogs, UserIdHash> found_common_dialogs_;
std::unordered_map<int64, std::pair<int32, vector<DialogId>>>
found_blocked_dialogs_; // random_id -> [total_count, [dialog_id]...]
std::unordered_map<int64, FullMessageId> get_dialog_message_by_date_results_; std::unordered_map<int64, FullMessageId> get_dialog_message_by_date_results_;
std::unordered_map<int64, std::pair<int32, vector<MessageId>>> std::unordered_map<int64, std::pair<int32, vector<MessageId>>>

28
td/telegram/Td.cpp
View File

@ -1861,31 +1861,6 @@ class GetChatEventLogRequest final : public RequestOnceActor {
} }
}; };
class GetBlockedMessageSendersRequest final : public RequestActor<> {
int32 offset_;
int32 limit_;
int64 random_id_;
std::pair<int32, vector<DialogId>> message_senders_;
void do_run(Promise<Unit> &&promise) final {
message_senders_ = td->messages_manager_->get_blocked_dialogs(offset_, limit_, random_id_, std::move(promise));
}
void do_send_result() final {
auto senders =
transform(message_senders_.second, [messages_manager = td->messages_manager_.get()](DialogId dialog_id) {
return messages_manager->get_message_sender_object(dialog_id, "GetBlockedMessageSendersRequest");
});
send_result(td_api::make_object<td_api::messageSenders>(message_senders_.first, std::move(senders)));
}
public:
GetBlockedMessageSendersRequest(ActorShared<Td> td, uint64 request_id, int32 offset, int32 limit)
: RequestActor(std::move(td), request_id), offset_(offset), limit_(limit), random_id_(0) {
}
};
class ImportContactsRequest final : public RequestActor<> { class ImportContactsRequest final : public RequestActor<> {
vector<Contact> contacts_; vector<Contact> contacts_;
int64 random_id_; int64 random_id_;
@ -6598,7 +6573,8 @@ void Td::on_request(uint64 id, const td_api::blockMessageSenderFromReplies &requ
void Td::on_request(uint64 id, const td_api::getBlockedMessageSenders &request) { void Td::on_request(uint64 id, const td_api::getBlockedMessageSenders &request) {
CHECK_IS_USER(); CHECK_IS_USER();
CREATE_REQUEST(GetBlockedMessageSendersRequest, request.offset_, request.limit_); CREATE_REQUEST_PROMISE();
messages_manager_->get_blocked_dialogs(request.offset_, request.limit_, std::move(promise));
} }
void Td::on_request(uint64 id, td_api::addContact &request) { void Td::on_request(uint64 id, td_api::addContact &request) {