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

Merge remote-tracking branch 'td/master'

This commit is contained in:
Andrea Cavalli 2021-11-16 00:42:28 +01:00
parent 48e3660d2c 922fd9b17b
commit a248d81e5b
15 changed files with 312 additions and 322 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -361,6 +361,7 @@ set(TDLIB_SOURCE
td/telegram/MessageReplyInfo.cpp
td/telegram/MessagesDb.cpp
td/telegram/MessageSearchFilter.cpp
td/telegram/MessageSender.cpp
td/telegram/MessagesManager.cpp
td/telegram/MessageTtlSetting.cpp
td/telegram/misc.cpp
@ -563,6 +564,7 @@ set(TDLIB_SOURCE
td/telegram/MessageThreadInfo.h
td/telegram/MessagesDb.h
td/telegram/MessageSearchFilter.h
td/telegram/MessageSender.h
td/telegram/MessagesManager.h
td/telegram/MessageTtlSetting.h
td/telegram/misc.h

56
td/telegram/ContactsManager.cpp
View File

@ -25,6 +25,7 @@
#include "td/telegram/logevent/LogEvent.h"
#include "td/telegram/logevent/LogEventHelper.h"
#include "td/telegram/MemoryManager.h"
#include "td/telegram/MessageSender.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/MessageTtlSetting.h"
#include "td/telegram/misc.h"
@ -11850,7 +11851,7 @@ tl_object_ptr<td_api::chatMember> ContactsManager::get_chat_member_object(
td_->messages_manager_->force_create_dialog(dialog_id, "get_chat_member_object", true);
}
return td_api::make_object<td_api::chatMember>(
td_->messages_manager_->get_message_sender_object_const(dialog_id, "get_chat_member_object"),
get_message_sender_object_const(td_, dialog_id, "get_chat_member_object"),
get_user_id_object(dialog_participant.inviter_user_id_, "chatMember.inviter_user_id"),
dialog_participant.joined_date_, dialog_participant.status_.get_chat_member_status_object());
}
@ -14862,32 +14863,6 @@ std::pair<int32, vector<DialogId>> ContactsManager::search_among_dialogs(const v
return {narrow_cast<int32>(result.first), transform(result.second, [](int64 key) { return DialogId(key); })};
}
Result<DialogId> ContactsManager::get_participant_dialog_id(
const td_api::object_ptr<td_api::MessageSender> &participant_id) {
if (participant_id == nullptr) {
return Status::Error(400, "Member identifier is not specified");
}
switch (participant_id->get_id()) {
case td_api::messageSenderUser::ID: {
auto user_id = UserId(static_cast<const td_api::messageSenderUser *>(participant_id.get())->user_id_);
if (!user_id.is_valid()) {
return Status::Error(400, "Invalid user identifier specified");
}
return DialogId(user_id);
}
case td_api::messageSenderChat::ID: {
auto dialog_id = DialogId(static_cast<const td_api::messageSenderChat *>(participant_id.get())->chat_id_);
if (!dialog_id.is_valid()) {
return Status::Error(400, "Invalid chat identifier specified");
}
return dialog_id;
}
default:
UNREACHABLE();
return DialogId();
}
}
void ContactsManager::add_dialog_participant(DialogId dialog_id, UserId user_id, int32 forward_limit,
Promise<Unit> &&promise) {
if (!td_->messages_manager_->have_dialog_force(dialog_id, "add_dialog_participant")) {
@ -14931,13 +14906,8 @@ void ContactsManager::add_dialog_participants(DialogId dialog_id, const vector<U
}
}
void ContactsManager::set_dialog_participant_status(DialogId dialog_id,
const tl_object_ptr<td_api::MessageSender> &participant_id,
const tl_object_ptr<td_api::ChatMemberStatus> &chat_member_status,
Promise<Unit> &&promise) {
TRY_RESULT_PROMISE(promise, participant_dialog_id, get_participant_dialog_id(participant_id));
auto status = get_dialog_participant_status(chat_member_status);
void ContactsManager::set_dialog_participant_status(DialogId dialog_id, DialogId participant_dialog_id,
DialogParticipantStatus &&status, Promise<Unit> &&promise) {
if (!td_->messages_manager_->have_dialog_force(dialog_id, "set_dialog_participant_status")) {
return promise.set_error(Status::Error(400, "Chat not found"));
}
@ -14966,11 +14936,8 @@ void ContactsManager::set_dialog_participant_status(DialogId dialog_id,
}
}
void ContactsManager::ban_dialog_participant(DialogId dialog_id,
const tl_object_ptr<td_api::MessageSender> &participant_id,
void ContactsManager::ban_dialog_participant(DialogId dialog_id, DialogId participant_dialog_id,
int32 banned_until_date, bool revoke_messages, Promise<Unit> &&promise) {
TRY_RESULT_PROMISE(promise, participant_dialog_id, get_participant_dialog_id(participant_id));
if (!td_->messages_manager_->have_dialog_force(dialog_id, "ban_dialog_participant")) {
return promise.set_error(Status::Error(400, "Chat not found"));
}
@ -14995,18 +14962,15 @@ void ContactsManager::ban_dialog_participant(DialogId dialog_id,
}
}
void ContactsManager::get_dialog_participant(DialogId dialog_id,
const tl_object_ptr<td_api::MessageSender> &participant_id,
void ContactsManager::get_dialog_participant(DialogId dialog_id, DialogId participant_dialog_id,
Promise<td_api::object_ptr<td_api::chatMember>> &&promise) {
TRY_RESULT_PROMISE(promise, participant_dialog_id, get_participant_dialog_id(participant_id));
auto new_promise = PromiseCreator::lambda(
[actor_id = actor_id(this), promise = std::move(promise)](Result<DialogParticipant> &&result) mutable {
TRY_RESULT_PROMISE(promise, dialog_participant, std::move(result));
send_closure(actor_id, &ContactsManager::finish_get_dialog_participant, std::move(dialog_participant),
std::move(promise));
});
get_dialog_participant(dialog_id, participant_dialog_id, std::move(new_promise));
do_get_dialog_participant(dialog_id, participant_dialog_id, std::move(new_promise));
}
void ContactsManager::finish_get_dialog_participant(DialogParticipant &&dialog_participant,
@ -15023,10 +14987,10 @@ void ContactsManager::finish_get_dialog_participant(DialogParticipant &&dialog_p
promise.set_value(get_chat_member_object(dialog_participant));
}
void ContactsManager::get_dialog_participant(DialogId dialog_id, DialogId participant_dialog_id,
Promise<DialogParticipant> &&promise) {
void ContactsManager::do_get_dialog_participant(DialogId dialog_id, DialogId participant_dialog_id,
Promise<DialogParticipant> &&promise) {
LOG(INFO) << "Receive GetChatMember request to get " << participant_dialog_id << " in " << dialog_id;
if (!td_->messages_manager_->have_dialog_force(dialog_id, "get_dialog_participant")) {
if (!td_->messages_manager_->have_dialog_force(dialog_id, "do_get_dialog_participant")) {
return promise.set_error(Status::Error(400, "Chat not found"));
}

16
td/telegram/ContactsManager.h
View File

@ -528,14 +528,13 @@ class ContactsManager final : public Actor {
void add_dialog_participants(DialogId dialog_id, const vector<UserId> &user_ids, Promise<Unit> &&promise);
void set_dialog_participant_status(DialogId dialog_id, const tl_object_ptr<td_api::MessageSender> &participant_id,
const tl_object_ptr<td_api::ChatMemberStatus> &chat_member_status,
Promise<Unit> &&promise);
void set_dialog_participant_status(DialogId dialog_id, DialogId participant_dialog_id,
DialogParticipantStatus &&status, Promise<Unit> &&promise);
void ban_dialog_participant(DialogId dialog_id, const tl_object_ptr<td_api::MessageSender> &participant_id,
int32 banned_until_date, bool revoke_messages, Promise<Unit> &&promise);
void ban_dialog_participant(DialogId dialog_id, DialogId participant_dialog_id, int32 banned_until_date,
bool revoke_messages, Promise<Unit> &&promise);
void get_dialog_participant(DialogId dialog_id, const tl_object_ptr<td_api::MessageSender> &participant_id,
void get_dialog_participant(DialogId dialog_id, DialogId participant_dialog_id,
Promise<td_api::object_ptr<td_api::chatMember>> &&promise);
void search_dialog_participants(DialogId dialog_id, const string &query, int32 limit, DialogParticipantsFilter filter,
@ -1421,8 +1420,6 @@ class ContactsManager final : public Actor {
bool update_permanent_invite_link(DialogInviteLink &invite_link, DialogInviteLink new_invite_link);
static Result<DialogId> get_participant_dialog_id(const td_api::object_ptr<td_api::MessageSender> &participant_id);
void add_chat_participant(ChatId chat_id, UserId user_id, int32 forward_limit, Promise<Unit> &&promise);
void add_channel_participant(ChannelId channel_id, UserId user_id, const DialogParticipantStatus &old_status,
@ -1443,7 +1440,8 @@ class ContactsManager final : public Actor {
DialogParticipants search_private_chat_participants(UserId my_user_id, UserId peer_user_id, const string &query,
int32 limit, DialogParticipantsFilter filter) const;
void get_dialog_participant(DialogId dialog_id, DialogId participant_dialog_id, Promise<DialogParticipant> &&promise);
void do_get_dialog_participant(DialogId dialog_id, DialogId participant_dialog_id,
Promise<DialogParticipant> &&promise);
void finish_get_dialog_participant(DialogParticipant &&dialog_participant,
Promise<td_api::object_ptr<td_api::chatMember>> &&promise);

15
td/telegram/DialogEventLog.cpp
View File

@ -15,6 +15,7 @@
#include "td/telegram/GroupCallManager.h"
#include "td/telegram/GroupCallParticipant.h"
#include "td/telegram/InputGroupCallId.h"
#include "td/telegram/MessageSender.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/MessageTtlSetting.h"
#include "td/telegram/StickersManager.h"
@ -86,8 +87,7 @@ static td_api::object_ptr<td_api::ChatEventAction> get_chat_event_action_object(
return nullptr;
}
return td_api::make_object<td_api::chatEventMemberRestricted>(
td->messages_manager_->get_message_sender_object(old_dialog_participant.dialog_id_,
"chatEventMemberRestricted"),
get_message_sender_object(td, old_dialog_participant.dialog_id_, "chatEventMemberRestricted"),
old_dialog_participant.status_.get_chat_member_status_object(),
new_dialog_participant.status_.get_chat_member_status_object());
}
@ -294,9 +294,7 @@ static td_api::object_ptr<td_api::ChatEventAction> get_chat_event_action_object(
return nullptr;
}
return td_api::make_object<td_api::chatEventVideoChatParticipantIsMutedToggled>(
td->messages_manager_->get_message_sender_object(participant.dialog_id,
"chatEventVideoChatParticipantIsMutedToggled"),
true);
get_message_sender_object(td, participant.dialog_id, "chatEventVideoChatParticipantIsMutedToggled"), true);
}
case telegram_api::channelAdminLogEventActionParticipantUnmute::ID: {
auto action = move_tl_object_as<telegram_api::channelAdminLogEventActionParticipantUnmute>(action_ptr);
@ -305,9 +303,7 @@ static td_api::object_ptr<td_api::ChatEventAction> get_chat_event_action_object(
return nullptr;
}
return td_api::make_object<td_api::chatEventVideoChatParticipantIsMutedToggled>(
td->messages_manager_->get_message_sender_object(participant.dialog_id,
"chatEventVideoChatParticipantIsMutedToggled"),
false);
get_message_sender_object(td, participant.dialog_id, "chatEventVideoChatParticipantIsMutedToggled"), false);
}
case telegram_api::channelAdminLogEventActionParticipantVolume::ID: {
auto action = move_tl_object_as<telegram_api::channelAdminLogEventActionParticipantVolume>(action_ptr);
@ -316,8 +312,7 @@ static td_api::object_ptr<td_api::ChatEventAction> get_chat_event_action_object(
return nullptr;
}
return td_api::make_object<td_api::chatEventVideoChatParticipantVolumeLevelChanged>(
td->messages_manager_->get_message_sender_object(participant.dialog_id,
"chatEventVideoChatParticipantVolumeLevelChanged"),
get_message_sender_object(td, participant.dialog_id, "chatEventVideoChatParticipantVolumeLevelChanged"),
participant.volume_level);
}
case telegram_api::channelAdminLogEventActionToggleGroupCallSetting::ID: {

52
td/telegram/GroupCallManager.cpp
View File

@ -15,6 +15,7 @@
#include "td/telegram/Global.h"
#include "td/telegram/MessageId.h"
#include "td/telegram/MemoryManager.h"
#include "td/telegram/MessageSender.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/misc.h"
#include "td/telegram/net/DcId.h"
@ -105,23 +106,7 @@ class GetGroupCallJoinAsQuery final : public Td::ResultHandler {
td_->contacts_manager_->on_get_users(std::move(ptr->users_), "GetGroupCallJoinAsQuery");
td_->contacts_manager_->on_get_chats(std::move(ptr->chats_), "GetGroupCallJoinAsQuery");
vector<td_api::object_ptr<td_api::MessageSender>> participant_aliaces;
for (auto &peer : ptr->peers_) {
DialogId dialog_id(peer);
if (!dialog_id.is_valid()) {
LOG(ERROR) << "Receive invalid " << dialog_id << " as join as peer for " << dialog_id_;
continue;
}
if (dialog_id.get_type() != DialogType::User) {
td_->messages_manager_->force_create_dialog(dialog_id, "GetGroupCallJoinAsQuery");
}
participant_aliaces.push_back(
td_->messages_manager_->get_message_sender_object(dialog_id, "GetGroupCallJoinAsQuery"));
}
promise_.set_value(td_api::make_object<td_api::messageSenders>(static_cast<int32>(participant_aliaces.size()),
std::move(participant_aliaces)));
promise_.set_value(convert_message_senders_object(td_, ptr->peers_));
}
void on_error(Status status) final {
@ -1099,32 +1084,6 @@ void GroupCallManager::on_sync_participants_timeout(GroupCallId group_call_id) {
sync_group_call_participants(input_group_call_id);
}
DialogId GroupCallManager::get_group_call_participant_id(
const td_api::object_ptr<td_api::MessageSender> &message_sender) {
if (message_sender == nullptr) {
return DialogId();
}
switch (message_sender->get_id()) {
case td_api::messageSenderUser::ID: {
UserId user_id(static_cast<const td_api::messageSenderUser *>(message_sender.get())->user_id_);
if (td_->contacts_manager_->have_user_force(user_id)) {
return DialogId(user_id);
}
break;
}
case td_api::messageSenderChat::ID: {
DialogId dialog_id(static_cast<const td_api::messageSenderChat *>(message_sender.get())->chat_id_);
if (td_->messages_manager_->have_dialog_force(dialog_id, "get_group_call_participant_id")) {
return dialog_id;
}
break;
}
default:
UNREACHABLE();
}
return DialogId();
}
bool GroupCallManager::is_group_call_being_joined(InputGroupCallId input_group_call_id) const {
return pending_join_requests_.count(input_group_call_id) != 0;
}
@ -4662,11 +4621,10 @@ vector<td_api::object_ptr<td_api::groupCallRecentSpeaker>> GroupCallManager::get
recent_speaker_update_timeout_.add_timeout_in(group_call->group_call_id.get(), next_timeout);
}
auto get_result = [recent_speaker_users, messages_manager = td_->messages_manager_.get()] {
return transform(recent_speaker_users, [messages_manager](const std::pair<DialogId, bool> &recent_speaker_user) {
auto get_result = [recent_speaker_users, td = td_] {
return transform(recent_speaker_users, [td](const std::pair<DialogId, bool> &recent_speaker_user) {
return td_api::make_object<td_api::groupCallRecentSpeaker>(
messages_manager->get_message_sender_object(recent_speaker_user.first, "get_recent_speakers"),
recent_speaker_user.second);
get_message_sender_object(td, recent_speaker_user.first, "get_recent_speakers"), recent_speaker_user.second);
});
};
if (recent_speakers->last_sent_users != recent_speaker_users) {

4
td/telegram/GroupCallParticipant.cpp
View File

@ -7,7 +7,7 @@
#include "td/telegram/GroupCallParticipant.h"
#include "td/telegram/Global.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/MessageSender.h"
#include "td/telegram/Td.h"
#include "td/utils/logging.h"
@ -266,7 +266,7 @@ td_api::object_ptr<td_api::groupCallParticipant> GroupCallParticipant::get_group
}
return td_api::make_object<td_api::groupCallParticipant>(
td->messages_manager_->get_message_sender_object(dialog_id, "get_group_call_participant_object"), audio_source,
get_message_sender_object(td, dialog_id, "get_group_call_participant_object"), audio_source,
presentation_audio_source, video_payload.get_group_call_participant_video_info_object(),
presentation_payload.get_group_call_participant_video_info_object(), about, is_self, is_speaking,
get_is_hand_raised(), can_be_muted_for_all_users, can_be_unmuted_for_all_users, can_be_muted_only_for_self,

6
td/telegram/MessageContent.cpp
View File

@ -39,6 +39,7 @@
#include "td/telegram/MessageEntity.hpp"
#include "td/telegram/MessageId.h"
#include "td/telegram/MessageSearchFilter.h"
#include "td/telegram/MessageSender.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/misc.h"
#include "td/telegram/net/DcId.h"
@ -4996,9 +4997,8 @@ tl_object_ptr<td_api::MessageContent> get_message_content_object(const MessageCo
case MessageContentType::ProximityAlertTriggered: {
const auto *m = static_cast<const MessageProximityAlertTriggered *>(content);
return make_tl_object<td_api::messageProximityAlertTriggered>(
td->messages_manager_->get_message_sender_object(m->traveler_dialog_id, "messageProximityAlertTriggered 1"),
td->messages_manager_->get_message_sender_object(m->watcher_dialog_id, "messageProximityAlertTriggered 2"),
m->distance);
get_message_sender_object(td, m->traveler_dialog_id, "messageProximityAlertTriggered 1"),
get_message_sender_object(td, m->watcher_dialog_id, "messageProximityAlertTriggered 2"), m->distance);
}
case MessageContentType::GroupCall: {
const auto *m = static_cast<const MessageGroupCall *>(content);

144
td/telegram/MessageSender.cpp Normal file
View File

@ -0,0 +1,144 @@
//
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2021
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#include "td/telegram/MessageSender.h"
#include "td/telegram/AuthManager.h"
#include "td/telegram/ContactsManager.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/Td.h"
#include "td/utils/algorithm.h"
#include "td/utils/misc.h"
namespace td {
td_api::object_ptr<td_api::MessageSender> get_message_sender_object_const(Td *td, UserId user_id, DialogId dialog_id,
const char *source) {
if (dialog_id.is_valid() && td->messages_manager_->have_dialog(dialog_id)) {
return td_api::make_object<td_api::messageSenderChat>(dialog_id.get());
}
if (!user_id.is_valid()) {
// can happen only if the server sends a message with wrong sender
LOG(ERROR) << "Receive message with wrong sender " << user_id << '/' << dialog_id << " from " << source;
user_id = td->contacts_manager_->add_service_notifications_user();
}
return td_api::make_object<td_api::messageSenderUser>(td->contacts_manager_->get_user_id_object(user_id, source));
}
td_api::object_ptr<td_api::MessageSender> get_message_sender_object_const(Td *td, DialogId dialog_id,
const char *source) {
if (dialog_id.get_type() == DialogType::User) {
return get_message_sender_object_const(td, dialog_id.get_user_id(), DialogId(), source);
}
return get_message_sender_object_const(td, UserId(), dialog_id, source);
}
td_api::object_ptr<td_api::MessageSender> get_message_sender_object(Td *td, UserId user_id, DialogId dialog_id,
const char *source) {
if (dialog_id.is_valid() && !td->messages_manager_->have_dialog(dialog_id)) {
LOG(ERROR) << "Failed to find " << dialog_id;
td->messages_manager_->force_create_dialog(dialog_id, source);
}
if (!user_id.is_valid() && td->auth_manager_->is_bot()) {
td->contacts_manager_->add_anonymous_bot_user();
td->contacts_manager_->add_service_notifications_user();
}
return get_message_sender_object_const(td, user_id, dialog_id, source);
}
td_api::object_ptr<td_api::MessageSender> get_message_sender_object(Td *td, DialogId dialog_id, const char *source) {
if (dialog_id.get_type() == DialogType::User) {
return get_message_sender_object(td, dialog_id.get_user_id(), DialogId(), source);
}
return get_message_sender_object(td, UserId(), dialog_id, source);
}
vector<DialogId> get_message_sender_dialog_ids(Td *td,
const vector<telegram_api::object_ptr<telegram_api::Peer>> &peers) {
vector<DialogId> message_sender_dialog_ids;
message_sender_dialog_ids.reserve(peers.size());
for (auto &peer : peers) {
DialogId dialog_id(peer);
if (!dialog_id.is_valid()) {
LOG(ERROR) << "Receive invalid " << dialog_id << " as message sender";
continue;
}
if (dialog_id.get_type() == DialogType::User) {
if (!td->contacts_manager_->have_user(dialog_id.get_user_id())) {
LOG(ERROR) << "Have no info about " << dialog_id.get_user_id();
continue;
}
} else {
if (!td->messages_manager_->have_dialog_info(dialog_id)) {
continue;
}
td->messages_manager_->force_create_dialog(dialog_id, "get_message_sender_dialog_ids");
if (!td->messages_manager_->have_dialog(dialog_id)) {
continue;
}
}
message_sender_dialog_ids.push_back(dialog_id);
}
return message_sender_dialog_ids;
}
td_api::object_ptr<td_api::messageSenders> convert_message_senders_object(
Td *td, const vector<telegram_api::object_ptr<telegram_api::Peer>> &peers) {
auto dialog_ids = get_message_sender_dialog_ids(td, peers);
auto message_senders = transform(dialog_ids, [td](DialogId dialog_id) {
return get_message_sender_object(td, dialog_id, "convert_message_senders_object");
});
return td_api::make_object<td_api::messageSenders>(narrow_cast<int32>(dialog_ids.size()), std::move(message_senders));
}
Result<DialogId> get_message_sender_dialog_id(Td *td,
const td_api::object_ptr<td_api::MessageSender> &message_sender_id,
bool check_access, bool allow_empty) {
if (message_sender_id == nullptr) {
if (allow_empty) {
return DialogId();
}
return Status::Error(400, "Message sender must be non-empty");
}
switch (message_sender_id->get_id()) {
case td_api::messageSenderUser::ID: {
auto user_id = UserId(static_cast<const td_api::messageSenderUser *>(message_sender_id.get())->user_id_);
if (!user_id.is_valid()) {
if (allow_empty && user_id == UserId()) {
return DialogId();
}
return Status::Error(400, "Invalid user identifier specified");
}
if (check_access && !td->contacts_manager_->have_user_force(user_id)) {
return Status::Error(400, "Unknown user identifier specified");
}
return DialogId(user_id);
}
case td_api::messageSenderChat::ID: {
auto dialog_id = DialogId(static_cast<const td_api::messageSenderChat *>(message_sender_id.get())->chat_id_);
if (!dialog_id.is_valid()) {
if (allow_empty && dialog_id == DialogId()) {
return DialogId();
}
return Status::Error(400, "Invalid chat identifier specified");
}
if (check_access) {
bool is_user = dialog_id.get_type() == DialogType::User;
if (is_user ? !td->contacts_manager_->have_user_force(dialog_id.get_user_id())
: !td->messages_manager_->have_dialog_force(dialog_id, "get_message_sender_dialog_id")) {
return Status::Error(400, "Unknown chat identifier specified");
}
}
return dialog_id;
}
default:
UNREACHABLE();
return DialogId();
}
}
} // namespace td

41
td/telegram/MessageSender.h Normal file
View File

@ -0,0 +1,41 @@
//
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2021
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#pragma once
#include "td/telegram/DialogId.h"
#include "td/telegram/td_api.h"
#include "td/telegram/UserId.h"
#include "td/utils/common.h"
#include "td/utils/Status.h"
namespace td {
class Td;
td_api::object_ptr<td_api::MessageSender> get_message_sender_object_const(Td *td, UserId user_id, DialogId dialog_id,
const char *source);
td_api::object_ptr<td_api::MessageSender> get_message_sender_object_const(Td *td, DialogId dialog_id,
const char *source);
td_api::object_ptr<td_api::MessageSender> get_message_sender_object(Td *td, UserId user_id, DialogId dialog_id,
const char *source);
td_api::object_ptr<td_api::MessageSender> get_message_sender_object(Td *td, DialogId dialog_id, const char *source);
vector<DialogId> get_message_sender_dialog_ids(Td *td,
const vector<telegram_api::object_ptr<telegram_api::Peer>> &peers);
td_api::object_ptr<td_api::messageSenders> convert_message_senders_object(
Td *td, const vector<telegram_api::object_ptr<telegram_api::Peer>> &peers);
Result<DialogId> get_message_sender_dialog_id(Td *td,
const td_api::object_ptr<td_api::MessageSender> &message_sender_id,
bool check_access, bool allow_empty);
} // namespace td

211
td/telegram/MessagesManager.cpp
View File

@ -34,6 +34,7 @@
#include "td/telegram/MessageEntity.h"
#include "td/telegram/MessageEntity.hpp"
#include "td/telegram/MessagesDb.h"
#include "td/telegram/MessageSender.h"
#include "td/telegram/misc.h"
#include "td/telegram/net/DcId.h"
#include "td/telegram/net/NetActor.h"
@ -2185,7 +2186,7 @@ class GetSearchResultCalendarQuery final : public Td::ResultHandler {
}
void on_error(Status status) final {
td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "SearchMessagesQuery");
td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "GetSearchResultCalendarQuery");
td_->messages_manager_->on_failed_get_message_search_result_calendar(dialog_id_, random_id_);
promise_.set_error(std::move(status));
}
@ -5860,49 +5861,6 @@ void MessagesManager::on_preload_folder_dialog_list_timeout_callback(void *messa
FolderId(narrow_cast<int32>(folder_id_int)));
}
td_api::object_ptr<td_api::MessageSender> MessagesManager::get_message_sender_object_const(UserId user_id,
DialogId dialog_id,
const char *source) const {
if (dialog_id.is_valid() && have_dialog(dialog_id)) {
return td_api::make_object<td_api::messageSenderChat>(dialog_id.get());
}
if (!user_id.is_valid()) {
// can happen only if the server sends a message with wrong sender
LOG(ERROR) << "Receive message with wrong sender " << user_id << '/' << dialog_id << " from " << source;
user_id = td_->contacts_manager_->add_service_notifications_user();
}
return td_api::make_object<td_api::messageSenderUser>(td_->contacts_manager_->get_user_id_object(user_id, source));
}
td_api::object_ptr<td_api::MessageSender> MessagesManager::get_message_sender_object(UserId user_id, DialogId dialog_id,
const char *source) {
if (dialog_id.is_valid() && !have_dialog(dialog_id)) {
LOG(ERROR) << "Failed to find " << dialog_id;
force_create_dialog(dialog_id, source);
}
if (!user_id.is_valid() && td_->auth_manager_->is_bot()) {
td_->contacts_manager_->add_anonymous_bot_user();
td_->contacts_manager_->add_service_notifications_user();
}
return get_message_sender_object_const(user_id, dialog_id, source);
}
td_api::object_ptr<td_api::MessageSender> MessagesManager::get_message_sender_object_const(DialogId dialog_id,
const char *source) const {
if (dialog_id.get_type() == DialogType::User) {
return get_message_sender_object_const(dialog_id.get_user_id(), DialogId(), source);
}
return get_message_sender_object_const(UserId(), dialog_id, source);
}
td_api::object_ptr<td_api::MessageSender> MessagesManager::get_message_sender_object(DialogId dialog_id,
const char *source) {
if (dialog_id.get_type() == DialogType::User) {
return get_message_sender_object(dialog_id.get_user_id(), DialogId(), source);
}
return get_message_sender_object(UserId(), dialog_id, source);
}
BufferSlice MessagesManager::get_dialog_database_value(const Dialog *d) {
// can't use log_event_store, because it tries to parse stored Dialog
LogEventStorerCalcLength storer_calc_length;
@ -17009,34 +16967,17 @@ void MessagesManager::on_get_blocked_dialogs(int32 offset, int32 limit, int32 to
Promise<td_api::object_ptr<td_api::messageSenders>> &&promise) {
LOG(INFO) << "Receive " << blocked_peers.size() << " blocked chats from offset " << offset << " out of "
<< total_count;
vector<DialogId> dialog_ids;
for (auto &blocked_peer : blocked_peers) {
CHECK(blocked_peer != nullptr);
DialogId dialog_id(blocked_peer->peer_id_);
if (dialog_id.get_type() == DialogType::User) {
if (td_->contacts_manager_->have_user(dialog_id.get_user_id())) {
dialog_ids.push_back(dialog_id);
} else {
LOG(ERROR) << "Have no info about " << dialog_id.get_user_id();
}
} else {
if (have_dialog_info(dialog_id)) {
force_create_dialog(dialog_id, "on_get_blocked_dialogs");
if (have_dialog(dialog_id)) {
dialog_ids.push_back(dialog_id);
}
} else {
LOG(ERROR) << "Have no info about " << dialog_id;
}
}
}
auto peers = transform(std::move(blocked_peers), [](tl_object_ptr<telegram_api::peerBlocked> &&blocked_peer) {
return std::move(blocked_peer->peer_id_);
});
auto dialog_ids = get_message_sender_dialog_ids(td_, std::move(peers));
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 + dialog_ids.size();
total_count = offset + narrow_cast<int32>(dialog_ids.size());
}
auto senders = transform(dialog_ids, [this](DialogId dialog_id) {
return get_message_sender_object(dialog_id, "on_get_blocked_dialogs");
auto senders = transform(dialog_ids, [td = td_](DialogId dialog_id) {
return get_message_sender_object(td, dialog_id, "on_get_blocked_dialogs");
});
promise.set_value(td_api::make_object<td_api::messageSenders>(total_count, std::move(senders)));
}
@ -19356,52 +19297,30 @@ void MessagesManager::toggle_dialog_is_marked_as_unread_on_server(DialogId dialo
Status MessagesManager::toggle_message_sender_is_blocked(const td_api::object_ptr<td_api::MessageSender> &sender,
bool is_blocked) {
if (sender == nullptr) {
return Status::Error(400, "Message sender must be non-empty");
}
UserId sender_user_id;
DialogId dialog_id;
switch (sender->get_id()) {
case td_api::messageSenderUser::ID:
sender_user_id = UserId(static_cast<const td_api::messageSenderUser *>(sender.get())->user_id_);
TRY_RESULT(dialog_id, get_message_sender_dialog_id(td_, sender, true, false));
switch (dialog_id.get_type()) {
case DialogType::User:
if (dialog_id == get_my_dialog_id()) {
return Status::Error(400, is_blocked ? Slice("Can't block self") : Slice("Can't unblock self"));
}
break;
case td_api::messageSenderChat::ID: {
auto sender_dialog_id = DialogId(static_cast<const td_api::messageSenderChat *>(sender.get())->chat_id_);
if (!have_dialog_force(sender_dialog_id, "toggle_message_sender_is_blocked")) {
return Status::Error(400, "Sender chat not found");
}
switch (sender_dialog_id.get_type()) {
case DialogType::User:
sender_user_id = sender_dialog_id.get_user_id();
break;
case DialogType::Chat:
return Status::Error(400, "Basic group chats can't be blocked");
case DialogType::Channel:
dialog_id = sender_dialog_id;
break;
case DialogType::SecretChat:
sender_user_id = td_->contacts_manager_->get_secret_chat_user_id(sender_dialog_id.get_secret_chat_id());
break;
case DialogType::None:
default:
UNREACHABLE();
case DialogType::Chat:
return Status::Error(400, "Basic group chats can't be blocked");
case DialogType::Channel:
// ok
break;
case DialogType::SecretChat: {
auto user_id = td_->contacts_manager_->get_secret_chat_user_id(dialog_id.get_secret_chat_id());
if (!user_id.is_valid() || !td_->contacts_manager_->have_user_force(user_id)) {
return Status::Error(400, "The secret chat can't be blocked");
}
dialog_id = DialogId(user_id);
break;
}
case DialogType::None:
default:
UNREACHABLE();
}
if (!dialog_id.is_valid()) {
if (!td_->contacts_manager_->have_user_force(sender_user_id)) {
return Status::Error(400, "Sender user not found");
}
dialog_id = DialogId(sender_user_id);
}
if (dialog_id == get_my_dialog_id()) {
return Status::Error(400, is_blocked ? Slice("Can't block self") : Slice("Can't unblock self"));
}
Dialog *d = get_dialog_force(dialog_id, "toggle_message_sender_is_blocked");
if (!have_input_peer(dialog_id, AccessRights::Know)) {
@ -20343,7 +20262,7 @@ td_api::object_ptr<td_api::videoChat> MessagesManager::get_video_chat_object(con
auto active_group_call_id = td_->group_call_manager_->get_group_call_id(d->active_group_call_id, d->dialog_id);
auto default_participant_alias =
d->default_join_group_call_as_dialog_id.is_valid()
? get_message_sender_object_const(d->default_join_group_call_as_dialog_id, "get_video_chat_object")
? get_message_sender_object_const(td_, d->default_join_group_call_as_dialog_id, "get_video_chat_object")
: nullptr;
return make_tl_object<td_api::videoChat>(active_group_call_id.get(),
active_group_call_id.is_valid() ? !d->is_group_call_empty : false,
@ -21577,44 +21496,18 @@ std::pair<int32, vector<MessageId>> MessagesManager::search_dialog_messages(
}
if (!have_input_peer(dialog_id, AccessRights::Read)) {
promise.set_error(Status::Error(400, "Can't access the chat"));
return {};
return result;
}
DialogId sender_dialog_id;
if (sender != nullptr) {
switch (sender->get_id()) {
case td_api::messageSenderUser::ID:
sender_dialog_id = DialogId(UserId(static_cast<const td_api::messageSenderUser *>(sender.get())->user_id_));
break;
case td_api::messageSenderChat::ID:
sender_dialog_id = DialogId(static_cast<const td_api::messageSenderChat *>(sender.get())->chat_id_);
switch (sender_dialog_id.get_type()) {
case DialogType::User:
case DialogType::Chat:
case DialogType::Channel:
// ok
break;
case DialogType::SecretChat:
promise.set_value(Unit());
return result;
case DialogType::None:
if (sender_dialog_id == DialogId()) {
break;
}
promise.set_error(Status::Error(400, "Invalid sender chat identifier specified"));
return result;
default:
UNREACHABLE();
return result;
}
break;
default:
UNREACHABLE();
}
if (sender_dialog_id != DialogId() && !have_input_peer(sender_dialog_id, AccessRights::Read)) {
promise.set_error(Status::Error(400, "Invalid message sender specified"));
return result;
}
auto r_sender_dialog_id = get_message_sender_dialog_id(td_, sender, true, true);
if (r_sender_dialog_id.is_error()) {
promise.set_error(r_sender_dialog_id.move_as_error());
return result;
}
auto sender_dialog_id = r_sender_dialog_id.move_as_ok();
if (sender_dialog_id != DialogId() && !have_input_peer(sender_dialog_id, AccessRights::Read)) {
promise.set_error(Status::Error(400, "Invalid message sender specified"));
return result;
}
if (sender_dialog_id == dialog_id && is_broadcast_channel(dialog_id)) {
sender_dialog_id = DialogId();
@ -21639,6 +21532,11 @@ std::pair<int32, vector<MessageId>> MessagesManager::search_dialog_messages(
}
}
if (sender_dialog_id.get_type() == DialogType::SecretChat) {
promise.set_value(Unit());
return result;
}
do {
random_id = Random::secure_int64();
} while (random_id == 0 || found_dialog_messages_.find(random_id) != found_dialog_messages_.end());
@ -23648,7 +23546,7 @@ tl_object_ptr<td_api::message> MessagesManager::get_message_object(DialogId dial
} else {
ttl = 0;
}
auto sender = get_message_sender_object_const(m->sender_user_id, m->sender_dialog_id, source);
auto sender = get_message_sender_object_const(td_, m->sender_user_id, m->sender_dialog_id, source);
auto scheduling_state = is_scheduled ? get_message_scheduling_state_object(m->date) : nullptr;
auto forward_info = get_message_forward_info_object(m->forward_info);
auto interaction_info = get_message_interaction_info_object(dialog_id, m);
@ -27377,24 +27275,13 @@ Result<MessageId> MessagesManager::add_local_message(
UserId sender_user_id;
DialogId sender_dialog_id;
if (sender != nullptr) {
switch (sender->get_id()) {
case td_api::messageSenderUser::ID:
sender_user_id = UserId(static_cast<const td_api::messageSenderUser *>(sender.get())->user_id_);
if (!td_->contacts_manager_->have_user_force(sender_user_id)) {
return Status::Error(400, "Sender user not found");
}
break;
case td_api::messageSenderChat::ID:
sender_dialog_id = DialogId(static_cast<const td_api::messageSenderChat *>(sender.get())->chat_id_);
if (sender_dialog_id.get_type() != DialogType::Channel) {
return Status::Error(400, "Sender chat must be a supergroup or channel");
}
if (!have_dialog_force(sender_dialog_id, "add_local_message")) {
return Status::Error(400, "Sender chat not found");
}
break;
default:
UNREACHABLE();
TRY_RESULT_ASSIGN(sender_dialog_id, get_message_sender_dialog_id(td_, sender, true, false));
auto sender_dialog_type = sender_dialog_id.get_type();
if (sender_dialog_type == DialogType::User) {
sender_user_id = sender_dialog_id.get_user_id();
sender_dialog_id = DialogId();
} else if (sender_dialog_type != DialogType::Channel) {
return Status::Error(400, "Sender chat must be a supergroup or channel");
}
} else if (is_channel_post) {
sender_dialog_id = dialog_id;

11
td/telegram/MessagesManager.h
View File

@ -144,17 +144,6 @@ class MessagesManager final : public Actor {
void memory_stats(vector<string> &output);
td_api::object_ptr<td_api::MessageSender> get_message_sender_object_const(UserId user_id, DialogId dialog_id,
const char *source) const;
td_api::object_ptr<td_api::MessageSender> get_message_sender_object(UserId user_id, DialogId dialog_id,
const char *source);
td_api::object_ptr<td_api::MessageSender> get_message_sender_object_const(DialogId dialog_id,
const char *source) const;
td_api::object_ptr<td_api::MessageSender> get_message_sender_object(DialogId dialog_id, const char *source);
static vector<MessageId> get_message_ids(const vector<int64> &input_message_ids);
static vector<int32> get_server_message_ids(const vector<MessageId> &message_ids);

1
td/telegram/NotificationManager.cpp
View File

@ -18,6 +18,7 @@
#include "td/telegram/files/FileManager.h"
#include "td/telegram/Global.h"
#include "td/telegram/logevent/LogEvent.h"
#include "td/telegram/MessageSender.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/misc.h"
#include "td/telegram/net/ConnectionCreator.h"

5
td/telegram/NotificationType.cpp
View File

@ -10,6 +10,7 @@
#include "td/telegram/AudiosManager.h"
#include "td/telegram/DocumentsManager.h"
#include "td/telegram/Global.h"
#include "td/telegram/MessageSender.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/StickersManager.h"
#include "td/telegram/Td.h"
@ -335,8 +336,8 @@ class NotificationTypePushMessage final : public NotificationType {
}
td_api::object_ptr<td_api::NotificationType> get_notification_type_object(DialogId dialog_id) const final {
auto sender = G()->td().get_actor_unsafe()->messages_manager_->get_message_sender_object(
sender_user_id_, sender_dialog_id_, "get_notification_type_object");
auto sender = get_message_sender_object(G()->td().get_actor_unsafe(), sender_user_id_, sender_dialog_id_,
"get_notification_type_object");
return td_api::make_object<td_api::notificationTypeNewPushMessage>(
message_id_.get(), std::move(sender), sender_name_, is_outgoing_,
get_push_message_content_object(key_, arg_, photo_, document_));

64
td/telegram/Td.cpp
View File

@ -60,6 +60,7 @@
#include "td/telegram/MessageId.h"
#include "td/telegram/MessageLinkInfo.h"
#include "td/telegram/MessageSearchFilter.h"
#include "td/telegram/MessageSender.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/MessageThreadInfo.h"
#include "td/telegram/misc.h"
@ -5840,9 +5841,10 @@ void Td::on_request(uint64 id, const td_api::getVideoChatAvailableParticipants &
void Td::on_request(uint64 id, const td_api::setVideoChatDefaultParticipant &request) {
CHECK_IS_USER();
CREATE_OK_REQUEST_PROMISE();
group_call_manager_->set_group_call_default_join_as(
DialogId(request.chat_id_), group_call_manager_->get_group_call_participant_id(request.default_participant_id_),
std::move(promise));
TRY_RESULT_PROMISE(promise, default_join_as_dialog_id,
get_message_sender_dialog_id(this, request.default_participant_id_, true, false));
group_call_manager_->set_group_call_default_join_as(DialogId(request.chat_id_), default_join_as_dialog_id,
std::move(promise));
}
void Td::on_request(uint64 id, td_api::createVideoChat &request) {
@ -5884,6 +5886,8 @@ void Td::on_request(uint64 id, td_api::joinGroupCall &request) {
CLEAN_INPUT_STRING(request.invite_hash_);
CLEAN_INPUT_STRING(request.payload_);
CREATE_REQUEST_PROMISE();
TRY_RESULT_PROMISE(promise, join_as_dialog_id,
get_message_sender_dialog_id(this, request.participant_id_, true, true));
auto query_promise = PromiseCreator::lambda([promise = std::move(promise)](Result<string> result) mutable {
if (result.is_error()) {
promise.set_error(result.move_as_error());
@ -5891,10 +5895,9 @@ void Td::on_request(uint64 id, td_api::joinGroupCall &request) {
promise.set_value(make_tl_object<td_api::text>(result.move_as_ok()));
}
});
group_call_manager_->join_group_call(GroupCallId(request.group_call_id_),
group_call_manager_->get_group_call_participant_id(request.participant_id_),
request.audio_source_id_, std::move(request.payload_), request.is_muted_,
request.is_my_video_enabled_, request.invite_hash_, std::move(query_promise));
group_call_manager_->join_group_call(GroupCallId(request.group_call_id_), join_as_dialog_id, request.audio_source_id_,
std::move(request.payload_), request.is_muted_, request.is_my_video_enabled_,
request.invite_hash_, std::move(query_promise));
}
void Td::on_request(uint64 id, td_api::startGroupCallScreenSharing &request) {
@ -6007,25 +6010,28 @@ void Td::on_request(uint64 id, const td_api::setGroupCallParticipantIsSpeaking &
void Td::on_request(uint64 id, const td_api::toggleGroupCallParticipantIsMuted &request) {
CHECK_IS_USER();
CREATE_OK_REQUEST_PROMISE();
TRY_RESULT_PROMISE(promise, participant_dialog_id,
get_message_sender_dialog_id(this, request.participant_id_, true, false));
group_call_manager_->toggle_group_call_participant_is_muted(
GroupCallId(request.group_call_id_), group_call_manager_->get_group_call_participant_id(request.participant_id_),
request.is_muted_, std::move(promise));
GroupCallId(request.group_call_id_), participant_dialog_id, request.is_muted_, std::move(promise));
}
void Td::on_request(uint64 id, const td_api::setGroupCallParticipantVolumeLevel &request) {
CHECK_IS_USER();
CREATE_OK_REQUEST_PROMISE();
TRY_RESULT_PROMISE(promise, participant_dialog_id,
get_message_sender_dialog_id(this, request.participant_id_, true, false));
group_call_manager_->set_group_call_participant_volume_level(
GroupCallId(request.group_call_id_), group_call_manager_->get_group_call_participant_id(request.participant_id_),
request.volume_level_, std::move(promise));
GroupCallId(request.group_call_id_), participant_dialog_id, request.volume_level_, std::move(promise));
}
void Td::on_request(uint64 id, const td_api::toggleGroupCallParticipantIsHandRaised &request) {
CHECK_IS_USER();
CREATE_OK_REQUEST_PROMISE();
TRY_RESULT_PROMISE(promise, participant_dialog_id,
get_message_sender_dialog_id(this, request.participant_id_, true, false));
group_call_manager_->toggle_group_call_participant_is_hand_raised(
GroupCallId(request.group_call_id_), group_call_manager_->get_group_call_participant_id(request.participant_id_),
request.is_hand_raised_, std::move(promise));
GroupCallId(request.group_call_id_), participant_dialog_id, request.is_hand_raised_, std::move(promise));
}
void Td::on_request(uint64 id, const td_api::loadGroupCallParticipants &request) {
@ -6256,7 +6262,7 @@ void Td::on_request(uint64 id, const td_api::joinChat &request) {
void Td::on_request(uint64 id, const td_api::leaveChat &request) {
CREATE_OK_REQUEST_PROMISE();
DialogId dialog_id(request.chat_id_);
td_api::object_ptr<td_api::ChatMemberStatus> new_status = td_api::make_object<td_api::chatMemberStatusLeft>();
auto new_status = DialogParticipantStatus::Left();
if (dialog_id.get_type() == DialogType::Channel && messages_manager_->have_dialog_force(dialog_id, "leaveChat")) {
auto status = contacts_manager_->get_channel_status(dialog_id.get_channel_id());
if (status.is_creator()) {
@ -6264,13 +6270,11 @@ void Td::on_request(uint64 id, const td_api::leaveChat &request) {
return promise.set_value(Unit());
}
new_status =
td_api::make_object<td_api::chatMemberStatusCreator>(status.get_rank(), status.is_anonymous(), false);
new_status = DialogParticipantStatus::Creator(false, status.is_anonymous(), status.get_rank());
}
}
contacts_manager_->set_dialog_participant_status(
dialog_id, td_api::make_object<td_api::messageSenderUser>(contacts_manager_->get_my_id().get()), new_status,
std::move(promise));
contacts_manager_->set_dialog_participant_status(dialog_id, DialogId(contacts_manager_->get_my_id()),
std::move(new_status), std::move(promise));
}
void Td::on_request(uint64 id, const td_api::addChatMember &request) {
@ -6287,16 +6291,20 @@ void Td::on_request(uint64 id, const td_api::addChatMembers &request) {
std::move(promise));
}
void Td::on_request(uint64 id, td_api::setChatMemberStatus &request) {
void Td::on_request(uint64 id, const td_api::setChatMemberStatus &request) {
CREATE_OK_REQUEST_PROMISE();
contacts_manager_->set_dialog_participant_status(DialogId(request.chat_id_), request.member_id_, request.status_,
std::move(promise));
TRY_RESULT_PROMISE(promise, participant_dialog_id,
get_message_sender_dialog_id(this, request.member_id_, false, false));
contacts_manager_->set_dialog_participant_status(DialogId(request.chat_id_), participant_dialog_id,
get_dialog_participant_status(request.status_), std::move(promise));
}
void Td::on_request(uint64 id, const td_api::banChatMember &request) {
CREATE_OK_REQUEST_PROMISE();
contacts_manager_->ban_dialog_participant(DialogId(request.chat_id_), request.member_id_, request.banned_until_date_,
request.revoke_messages_, std::move(promise));
TRY_RESULT_PROMISE(promise, participant_dialog_id,
get_message_sender_dialog_id(this, request.member_id_, false, false));
contacts_manager_->ban_dialog_participant(DialogId(request.chat_id_), participant_dialog_id,
request.banned_until_date_, request.revoke_messages_, std::move(promise));
}
void Td::on_request(uint64 id, const td_api::canTransferOwnership &request) {
@ -6321,9 +6329,11 @@ void Td::on_request(uint64 id, td_api::transferChatOwnership &request) {
std::move(promise));
}
void Td::on_request(uint64 id, td_api::getChatMember &request) {
void Td::on_request(uint64 id, const td_api::getChatMember &request) {
CREATE_REQUEST_PROMISE();
contacts_manager_->get_dialog_participant(DialogId(request.chat_id_), request.member_id_, std::move(promise));
TRY_RESULT_PROMISE(promise, participant_dialog_id,
get_message_sender_dialog_id(this, request.member_id_, false, false));
contacts_manager_->get_dialog_participant(DialogId(request.chat_id_), participant_dialog_id, std::move(promise));
}
void Td::on_request(uint64 id, td_api::searchChatMembers &request) {
@ -6341,7 +6351,7 @@ void Td::on_request(uint64 id, td_api::searchChatMembers &request) {
DialogParticipantsFilter(request.filter_), std::move(query_promise));
}
void Td::on_request(uint64 id, td_api::getChatAdministrators &request) {
void Td::on_request(uint64 id, const td_api::getChatAdministrators &request) {
CREATE_REQUEST(GetChatAdministratorsRequest, request.chat_id_);
}

6
td/telegram/Td.h
View File

@ -863,7 +863,7 @@ class Td final : public Actor {
void on_request(uint64 id, const td_api::addChatMembers &request);
void on_request(uint64 id, td_api::setChatMemberStatus &request);
void on_request(uint64 id, const td_api::setChatMemberStatus &request);
void on_request(uint64 id, const td_api::banChatMember &request);
@ -871,11 +871,11 @@ class Td final : public Actor {
void on_request(uint64 id, td_api::transferChatOwnership &request);
void on_request(uint64 id, td_api::getChatMember &request);
void on_request(uint64 id, const td_api::getChatMember &request);
void on_request(uint64 id, td_api::searchChatMembers &request);
void on_request(uint64 id, td_api::getChatAdministrators &request);
void on_request(uint64 id, const td_api::getChatAdministrators &request);
void on_request(uint64 id, const td_api::replacePrimaryChatInviteLink &request);