Move dialog participant methods from MessagesManager to ContactsManager.

This commit is contained in:
levlam 2021-01-27 02:16:17 +03:00
parent d246318a5c
commit cd3abdbeb2
6 changed files with 343 additions and 359 deletions

View File

@ -14064,7 +14064,7 @@ void ContactsManager::on_update_secret_chat(SecretChatId secret_chat_id, int64 a
}
std::pair<int32, vector<UserId>> ContactsManager::search_among_users(const vector<UserId> &user_ids,
const string &query, int32 limit) {
const string &query, int32 limit) const {
Hints hints; // TODO cache Hints
for (auto user_id : user_ids) {
@ -14085,6 +14085,272 @@ std::pair<int32, vector<UserId>> ContactsManager::search_among_users(const vecto
transform(result.second, [](int64 key) { return UserId(narrow_cast<int32>(key)); })};
}
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)) {
return promise.set_error(Status::Error(3, "Chat not found"));
}
switch (dialog_id.get_type()) {
case DialogType::User:
return promise.set_error(Status::Error(3, "Can't add members to a private chat"));
case DialogType::Chat:
return add_chat_participant(dialog_id.get_chat_id(), user_id, forward_limit, std::move(promise));
case DialogType::Channel:
return add_channel_participant(dialog_id.get_channel_id(), user_id, std::move(promise));
case DialogType::SecretChat:
return promise.set_error(Status::Error(3, "Can't add members to a secret chat"));
case DialogType::None:
default:
UNREACHABLE();
}
}
void ContactsManager::add_dialog_participants(DialogId dialog_id, const vector<UserId> &user_ids,
Promise<Unit> &&promise) {
if (td_->auth_manager_->is_bot()) {
return promise.set_error(Status::Error(3, "Method is not available for bots"));
}
if (!td_->messages_manager_->have_dialog_force(dialog_id)) {
return promise.set_error(Status::Error(3, "Chat not found"));
}
switch (dialog_id.get_type()) {
case DialogType::User:
return promise.set_error(Status::Error(3, "Can't add members to a private chat"));
case DialogType::Chat:
return promise.set_error(Status::Error(3, "Can't add many members at once to a basic group chat"));
case DialogType::Channel:
return add_channel_participants(dialog_id.get_channel_id(), user_ids, std::move(promise));
case DialogType::SecretChat:
return promise.set_error(Status::Error(3, "Can't add members to a secret chat"));
case DialogType::None:
default:
UNREACHABLE();
}
}
void ContactsManager::set_dialog_participant_status(DialogId dialog_id, UserId user_id,
const tl_object_ptr<td_api::ChatMemberStatus> &chat_member_status,
Promise<Unit> &&promise) {
auto status = get_dialog_participant_status(chat_member_status);
if (!td_->messages_manager_->have_dialog_force(dialog_id)) {
return promise.set_error(Status::Error(3, "Chat not found"));
}
switch (dialog_id.get_type()) {
case DialogType::User:
return promise.set_error(Status::Error(3, "Chat member status can't be changed in private chats"));
case DialogType::Chat:
return change_chat_participant_status(dialog_id.get_chat_id(), user_id, status, std::move(promise));
case DialogType::Channel:
return change_channel_participant_status(dialog_id.get_channel_id(), user_id, status, std::move(promise));
case DialogType::SecretChat:
return promise.set_error(Status::Error(3, "Chat member status can't be changed in secret chats"));
case DialogType::None:
default:
UNREACHABLE();
}
}
void ContactsManager::ban_dialog_participant(DialogId dialog_id, UserId user_id, int32 banned_until_date,
bool revoke_messages, Promise<Unit> &&promise) {
if (!td_->messages_manager_->have_dialog_force(dialog_id)) {
return promise.set_error(Status::Error(3, "Chat not found"));
}
switch (dialog_id.get_type()) {
case DialogType::User:
return promise.set_error(Status::Error(3, "Can't ban members in a private chat"));
case DialogType::Chat:
return delete_chat_participant(dialog_id.get_chat_id(), user_id, revoke_messages, std::move(promise));
case DialogType::Channel:
return change_channel_participant_status(dialog_id.get_channel_id(), user_id,
DialogParticipantStatus::Banned(banned_until_date), std::move(promise));
case DialogType::SecretChat:
return promise.set_error(Status::Error(3, "Can't ban members in a secret chat"));
case DialogType::None:
default:
UNREACHABLE();
}
}
DialogParticipant ContactsManager::get_dialog_participant(DialogId dialog_id, UserId user_id, int64 &random_id,
bool force, Promise<Unit> &&promise) {
LOG(INFO) << "Receive GetChatMember request to get " << user_id << " in " << dialog_id << " with random_id "
<< random_id;
if (!td_->messages_manager_->have_dialog_force(dialog_id)) {
promise.set_error(Status::Error(3, "Chat not found"));
return DialogParticipant();
}
switch (dialog_id.get_type()) {
case DialogType::User: {
auto peer_user_id = dialog_id.get_user_id();
if (user_id == get_my_id()) {
promise.set_value(Unit());
return {user_id, peer_user_id, 0, DialogParticipantStatus::Member()};
}
if (user_id == peer_user_id) {
promise.set_value(Unit());
return {peer_user_id, user_id, 0, DialogParticipantStatus::Member()};
}
promise.set_error(Status::Error(3, "User is not a member of the private chat"));
break;
}
case DialogType::Chat:
return get_chat_participant(dialog_id.get_chat_id(), user_id, force, std::move(promise));
case DialogType::Channel:
return get_channel_participant(dialog_id.get_channel_id(), user_id, random_id, force, std::move(promise));
case DialogType::SecretChat: {
auto peer_user_id = get_secret_chat_user_id(dialog_id.get_secret_chat_id());
if (user_id == get_my_id()) {
promise.set_value(Unit());
return {user_id, peer_user_id.is_valid() ? peer_user_id : user_id, 0, DialogParticipantStatus::Member()};
}
if (peer_user_id.is_valid() && user_id == peer_user_id) {
promise.set_value(Unit());
return {peer_user_id, user_id, 0, DialogParticipantStatus::Member()};
}
promise.set_error(Status::Error(3, "User is not a member of the secret chat"));
break;
}
case DialogType::None:
default:
UNREACHABLE();
promise.set_error(Status::Error(500, "Wrong chat type"));
}
return DialogParticipant();
}
DialogParticipants ContactsManager::search_private_chat_participants(UserId my_user_id, UserId peer_user_id,
const string &query, int32 limit,
DialogParticipantsFilter filter) const {
vector<UserId> user_ids;
switch (filter.type) {
case DialogParticipantsFilter::Type::Contacts:
if (peer_user_id.is_valid() && is_user_contact(peer_user_id)) {
user_ids.push_back(peer_user_id);
}
break;
case DialogParticipantsFilter::Type::Administrators:
break;
case DialogParticipantsFilter::Type::Members:
case DialogParticipantsFilter::Type::Mention:
user_ids.push_back(my_user_id);
if (peer_user_id.is_valid() && peer_user_id != my_user_id) {
user_ids.push_back(peer_user_id);
}
break;
case DialogParticipantsFilter::Type::Restricted:
break;
case DialogParticipantsFilter::Type::Banned:
break;
case DialogParticipantsFilter::Type::Bots:
if (td_->auth_manager_->is_bot()) {
user_ids.push_back(my_user_id);
}
if (peer_user_id.is_valid() && is_user_bot(peer_user_id) && peer_user_id != my_user_id) {
user_ids.push_back(peer_user_id);
}
break;
default:
UNREACHABLE();
}
auto result = search_among_users(user_ids, query, limit);
return {result.first, transform(result.second, [&](UserId user_id) {
return DialogParticipant(user_id,
user_id == my_user_id && peer_user_id.is_valid() ? peer_user_id : my_user_id, 0,
DialogParticipantStatus::Member());
})};
}
void ContactsManager::search_dialog_participants(DialogId dialog_id, const string &query, int32 limit,
DialogParticipantsFilter filter, bool without_bot_info,
Promise<DialogParticipants> &&promise) {
LOG(INFO) << "Receive searchChatMembers request to search for \"" << query << "\" in " << dialog_id << " with filter "
<< filter;
if (!td_->messages_manager_->have_dialog_force(dialog_id)) {
return promise.set_error(Status::Error(3, "Chat not found"));
}
if (limit < 0) {
return promise.set_error(Status::Error(3, "Parameter limit must be non-negative"));
}
switch (dialog_id.get_type()) {
case DialogType::User:
promise.set_value(search_private_chat_participants(get_my_id(), dialog_id.get_user_id(), query, limit, filter));
return;
case DialogType::Chat:
return search_chat_participants(dialog_id.get_chat_id(), query, limit, filter, std::move(promise));
case DialogType::Channel: {
td_api::object_ptr<td_api::SupergroupMembersFilter> request_filter;
string additional_query;
int32 additional_limit = 0;
switch (filter.type) {
case DialogParticipantsFilter::Type::Contacts:
request_filter = td_api::make_object<td_api::supergroupMembersFilterContacts>();
break;
case DialogParticipantsFilter::Type::Administrators:
request_filter = td_api::make_object<td_api::supergroupMembersFilterAdministrators>();
break;
case DialogParticipantsFilter::Type::Members:
request_filter = td_api::make_object<td_api::supergroupMembersFilterSearch>(query);
break;
case DialogParticipantsFilter::Type::Restricted:
request_filter = td_api::make_object<td_api::supergroupMembersFilterRestricted>(query);
break;
case DialogParticipantsFilter::Type::Banned:
request_filter = td_api::make_object<td_api::supergroupMembersFilterBanned>(query);
break;
case DialogParticipantsFilter::Type::Mention:
request_filter =
td_api::make_object<td_api::supergroupMembersFilterMention>(query, filter.top_thread_message_id.get());
break;
case DialogParticipantsFilter::Type::Bots:
request_filter = td_api::make_object<td_api::supergroupMembersFilterBots>();
break;
default:
UNREACHABLE();
}
switch (filter.type) {
case DialogParticipantsFilter::Type::Contacts:
case DialogParticipantsFilter::Type::Administrators:
case DialogParticipantsFilter::Type::Bots:
additional_query = query;
additional_limit = limit;
limit = 100;
break;
case DialogParticipantsFilter::Type::Members:
case DialogParticipantsFilter::Type::Restricted:
case DialogParticipantsFilter::Type::Banned:
case DialogParticipantsFilter::Type::Mention:
// query is passed to the server request
break;
default:
UNREACHABLE();
}
return get_channel_participants(dialog_id.get_channel_id(), std::move(request_filter),
std::move(additional_query), 0, limit, additional_limit, without_bot_info,
std::move(promise));
}
case DialogType::SecretChat: {
auto peer_user_id = get_secret_chat_user_id(dialog_id.get_secret_chat_id());
promise.set_value(search_private_chat_participants(get_my_id(), peer_user_id, query, limit, filter));
return;
}
case DialogType::None:
default:
UNREACHABLE();
promise.set_error(Status::Error(500, "Wrong chat type"));
}
}
DialogParticipant ContactsManager::get_chat_participant(ChatId chat_id, UserId user_id, bool force,
Promise<Unit> &&promise) {
LOG(INFO) << "Trying to get " << user_id << " as member of " << chat_id;
@ -14297,6 +14563,26 @@ void ContactsManager::do_get_channel_participants(ChannelId channel_id, ChannelP
vector<DialogAdministrator> ContactsManager::get_dialog_administrators(DialogId dialog_id, int left_tries,
Promise<Unit> &&promise) {
LOG(INFO) << "Receive GetChatAdministrators request in " << dialog_id << " with " << left_tries << " left tries";
if (!td_->messages_manager_->have_dialog_force(dialog_id)) {
promise.set_error(Status::Error(3, "Chat not found"));
return {};
}
switch (dialog_id.get_type()) {
case DialogType::User:
case DialogType::SecretChat:
promise.set_value(Unit());
return {};
case DialogType::Chat:
case DialogType::Channel:
break;
case DialogType::None:
default:
UNREACHABLE();
return {};
}
auto it = dialog_administrators_.find(dialog_id);
if (it != dialog_administrators_.end()) {
promise.set_value(Unit());

View File

@ -374,21 +374,6 @@ class ContactsManager : public Actor {
void load_statistics_graph(DialogId dialog_id, const string &token, int64 x,
Promise<td_api::object_ptr<td_api::StatisticalGraph>> &&promise);
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, Promise<Unit> &&promise,
DialogParticipantStatus old_status = DialogParticipantStatus::Left());
void add_channel_participants(ChannelId channel_id, const vector<UserId> &user_ids, Promise<Unit> &&promise);
void change_chat_participant_status(ChatId chat_id, UserId user_id, DialogParticipantStatus status,
Promise<Unit> &&promise);
void change_channel_participant_status(ChannelId channel_id, UserId user_id, DialogParticipantStatus status,
Promise<Unit> &&promise);
void delete_chat_participant(ChatId chat_id, UserId user_id, bool revoke_messages, Promise<Unit> &&promise);
void can_transfer_ownership(Promise<CanTransferOwnershipResult> &&promise);
static td_api::object_ptr<td_api::CanTransferOwnershipResult> get_can_transfer_ownership_result_object(
@ -503,24 +488,31 @@ class ContactsManager : public Actor {
ChannelId get_channel_linked_channel_id(ChannelId channel_id);
int32 get_channel_slow_mode_delay(ChannelId channel_id);
std::pair<int32, vector<UserId>> search_among_users(const vector<UserId> &user_ids, const string &query, int32 limit);
void add_dialog_participant(DialogId dialog_id, UserId user_id, int32 forward_limit, Promise<Unit> &&promise);
DialogParticipant get_chat_participant(ChatId chat_id, UserId user_id, bool force, Promise<Unit> &&promise);
void add_dialog_participants(DialogId dialog_id, const vector<UserId> &user_ids, Promise<Unit> &&promise);
void search_chat_participants(ChatId chat_id, const string &query, int32 limit, DialogParticipantsFilter filter,
Promise<DialogParticipants> &&promise);
void set_dialog_participant_status(DialogId dialog_id, UserId user_id,
const tl_object_ptr<td_api::ChatMemberStatus> &chat_member_status,
Promise<Unit> &&promise);
DialogParticipant get_channel_participant(ChannelId channel_id, UserId user_id, int64 &random_id, bool force,
Promise<Unit> &&promise);
void get_channel_participants(ChannelId channel_id, tl_object_ptr<td_api::SupergroupMembersFilter> &&filter,
string additional_query, int32 offset, int32 limit, int32 additional_limit,
bool without_bot_info, Promise<DialogParticipants> &&promise);
void ban_dialog_participant(DialogId dialog_id, UserId user_id, int32 banned_until_date, bool revoke_messages,
Promise<Unit> &&promise);
DialogParticipant get_dialog_participant(ChannelId channel_id,
tl_object_ptr<telegram_api::ChannelParticipant> &&participant_ptr) const;
vector<DialogAdministrator> get_dialog_administrators(DialogId chat_id, int left_tries, Promise<Unit> &&promise);
DialogParticipant get_dialog_participant(DialogId dialog_id, UserId user_id, int64 &random_id, bool force,
Promise<Unit> &&promise);
void search_dialog_participants(DialogId dialog_id, const string &query, int32 limit, DialogParticipantsFilter filter,
bool without_bot_info, Promise<DialogParticipants> &&promise);
vector<DialogAdministrator> get_dialog_administrators(DialogId dialog_id, int left_tries, Promise<Unit> &&promise);
void get_channel_participants(ChannelId channel_id, tl_object_ptr<td_api::SupergroupMembersFilter> &&filter,
string additional_query, int32 offset, int32 limit, int32 additional_limit,
bool without_bot_info, Promise<DialogParticipants> &&promise);
int32 get_user_id_object(UserId user_id, const char *source) const;
@ -1053,10 +1045,28 @@ class ContactsManager : public Actor {
bool update_permanent_invite_link(DialogInviteLink &invite_link, DialogInviteLink new_invite_link);
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, Promise<Unit> &&promise,
DialogParticipantStatus old_status = DialogParticipantStatus::Left());
void add_channel_participants(ChannelId channel_id, const vector<UserId> &user_ids, Promise<Unit> &&promise);
const DialogParticipant *get_chat_participant(ChatId chat_id, UserId user_id) const;
static const DialogParticipant *get_chat_participant(const ChatFull *chat_full, UserId user_id);
std::pair<int32, vector<UserId>> search_among_users(const vector<UserId> &user_ids, const string &query,
int32 limit) const;
DialogParticipants search_private_chat_participants(UserId my_user_id, UserId peer_user_id, const string &query,
int32 limit, DialogParticipantsFilter filter) const;
DialogParticipant get_chat_participant(ChatId chat_id, UserId user_id, bool force, Promise<Unit> &&promise);
DialogParticipant get_channel_participant(ChannelId channel_id, UserId user_id, int64 &random_id, bool force,
Promise<Unit> &&promise);
static string get_dialog_administrators_database_key(DialogId dialog_id);
void load_dialog_administrators(DialogId dialog_id, Promise<Unit> &&promise);
@ -1108,7 +1118,16 @@ class ContactsManager : public Actor {
void update_dialogs_for_discussion(DialogId dialog_id, bool is_suitable);
void delete_chat_participant(ChatId chat_id, UserId user_id, Promise<Unit> &&promise);
void change_chat_participant_status(ChatId chat_id, UserId user_id, DialogParticipantStatus status,
Promise<Unit> &&promise);
void change_channel_participant_status(ChannelId channel_id, UserId user_id, DialogParticipantStatus status,
Promise<Unit> &&promise);
void delete_chat_participant(ChatId chat_id, UserId user_id, bool revoke_messages, Promise<Unit> &&promise);
void search_chat_participants(ChatId chat_id, const string &query, int32 limit, DialogParticipantsFilter filter,
Promise<DialogParticipants> &&promise);
void do_search_chat_participants(ChatId chat_id, const string &query, int32 limit, DialogParticipantsFilter filter,
Promise<DialogParticipants> &&promise);

View File

@ -1490,7 +1490,7 @@ void GroupCallManager::try_load_group_call_administrators(InputGroupCallId input
send_closure(actor_id, &GroupCallManager::finish_load_group_call_administrators, input_group_call_id,
std::move(result));
});
td_->messages_manager_->search_dialog_participants(
td_->contacts_manager_->search_dialog_participants(
dialog_id, string(), 100, DialogParticipantsFilter(DialogParticipantsFilter::Type::Administrators), true,
std::move(promise));
}

View File

@ -30800,304 +30800,6 @@ void MessagesManager::unpin_all_dialog_messages_on_server(DialogId dialog_id, ui
->send(dialog_id);
}
void MessagesManager::add_dialog_participant(DialogId dialog_id, UserId user_id, int32 forward_limit,
Promise<Unit> &&promise) {
if (!have_dialog_force(dialog_id)) {
return promise.set_error(Status::Error(3, "Chat not found"));
}
switch (dialog_id.get_type()) {
case DialogType::User:
return promise.set_error(Status::Error(3, "Can't add members to a private chat"));
case DialogType::Chat:
return td_->contacts_manager_->add_chat_participant(dialog_id.get_chat_id(), user_id, forward_limit,
std::move(promise));
case DialogType::Channel:
return td_->contacts_manager_->add_channel_participant(dialog_id.get_channel_id(), user_id, std::move(promise));
case DialogType::SecretChat:
return promise.set_error(Status::Error(3, "Can't add members to a secret chat"));
case DialogType::None:
default:
UNREACHABLE();
}
}
void MessagesManager::add_dialog_participants(DialogId dialog_id, const vector<UserId> &user_ids,
Promise<Unit> &&promise) {
if (td_->auth_manager_->is_bot()) {
return promise.set_error(Status::Error(3, "Method is not available for bots"));
}
if (!have_dialog_force(dialog_id)) {
return promise.set_error(Status::Error(3, "Chat not found"));
}
switch (dialog_id.get_type()) {
case DialogType::User:
return promise.set_error(Status::Error(3, "Can't add members to a private chat"));
case DialogType::Chat:
return promise.set_error(Status::Error(3, "Can't add many members at once to a basic group chat"));
case DialogType::Channel:
return td_->contacts_manager_->add_channel_participants(dialog_id.get_channel_id(), user_ids, std::move(promise));
case DialogType::SecretChat:
return promise.set_error(Status::Error(3, "Can't add members to a secret chat"));
case DialogType::None:
default:
UNREACHABLE();
}
}
void MessagesManager::set_dialog_participant_status(DialogId dialog_id, UserId user_id,
const tl_object_ptr<td_api::ChatMemberStatus> &chat_member_status,
Promise<Unit> &&promise) {
auto status = get_dialog_participant_status(chat_member_status);
if (!have_dialog_force(dialog_id)) {
return promise.set_error(Status::Error(3, "Chat not found"));
}
switch (dialog_id.get_type()) {
case DialogType::User:
return promise.set_error(Status::Error(3, "Chat member status can't be changed in private chats"));
case DialogType::Chat:
return td_->contacts_manager_->change_chat_participant_status(dialog_id.get_chat_id(), user_id, status,
std::move(promise));
case DialogType::Channel:
return td_->contacts_manager_->change_channel_participant_status(dialog_id.get_channel_id(), user_id, status,
std::move(promise));
case DialogType::SecretChat:
return promise.set_error(Status::Error(3, "Chat member status can't be changed in secret chats"));
case DialogType::None:
default:
UNREACHABLE();
}
}
void MessagesManager::ban_dialog_participant(DialogId dialog_id, UserId user_id, int32 banned_until_date,
bool revoke_messages, Promise<Unit> &&promise) {
if (!have_dialog_force(dialog_id)) {
return promise.set_error(Status::Error(3, "Chat not found"));
}
switch (dialog_id.get_type()) {
case DialogType::User:
return promise.set_error(Status::Error(3, "Can't ban members in a private chat"));
case DialogType::Chat:
return td_->contacts_manager_->delete_chat_participant(dialog_id.get_chat_id(), user_id, revoke_messages,
std::move(promise));
case DialogType::Channel:
return td_->contacts_manager_->change_channel_participant_status(
dialog_id.get_channel_id(), user_id, DialogParticipantStatus::Banned(banned_until_date), std::move(promise));
case DialogType::SecretChat:
return promise.set_error(Status::Error(3, "Can't ban members in a secret chat"));
case DialogType::None:
default:
UNREACHABLE();
}
}
DialogParticipant MessagesManager::get_dialog_participant(DialogId dialog_id, UserId user_id, int64 &random_id,
bool force, Promise<Unit> &&promise) {
LOG(INFO) << "Receive GetChatMember request to get " << user_id << " in " << dialog_id << " with random_id "
<< random_id;
if (!have_dialog_force(dialog_id)) {
promise.set_error(Status::Error(3, "Chat not found"));
return DialogParticipant();
}
switch (dialog_id.get_type()) {
case DialogType::User: {
auto peer_user_id = dialog_id.get_user_id();
if (user_id == td_->contacts_manager_->get_my_id()) {
promise.set_value(Unit());
return {user_id, peer_user_id, 0, DialogParticipantStatus::Member()};
}
if (user_id == peer_user_id) {
promise.set_value(Unit());
return {peer_user_id, user_id, 0, DialogParticipantStatus::Member()};
}
promise.set_error(Status::Error(3, "User is not a member of the private chat"));
break;
}
case DialogType::Chat:
return td_->contacts_manager_->get_chat_participant(dialog_id.get_chat_id(), user_id, force, std::move(promise));
case DialogType::Channel:
return td_->contacts_manager_->get_channel_participant(dialog_id.get_channel_id(), user_id, random_id, force,
std::move(promise));
case DialogType::SecretChat: {
auto peer_user_id = td_->contacts_manager_->get_secret_chat_user_id(dialog_id.get_secret_chat_id());
if (user_id == td_->contacts_manager_->get_my_id()) {
promise.set_value(Unit());
return {user_id, peer_user_id.is_valid() ? peer_user_id : user_id, 0, DialogParticipantStatus::Member()};
}
if (peer_user_id.is_valid() && user_id == peer_user_id) {
promise.set_value(Unit());
return {peer_user_id, user_id, 0, DialogParticipantStatus::Member()};
}
promise.set_error(Status::Error(3, "User is not a member of the secret chat"));
break;
}
case DialogType::None:
default:
UNREACHABLE();
promise.set_error(Status::Error(500, "Wrong chat type"));
}
return DialogParticipant();
}
DialogParticipants MessagesManager::search_private_chat_participants(UserId my_user_id, UserId peer_user_id,
const string &query, int32 limit,
DialogParticipantsFilter filter) const {
vector<UserId> user_ids;
switch (filter.type) {
case DialogParticipantsFilter::Type::Contacts:
if (peer_user_id.is_valid() && td_->contacts_manager_->is_user_contact(peer_user_id)) {
user_ids.push_back(peer_user_id);
}
break;
case DialogParticipantsFilter::Type::Administrators:
break;
case DialogParticipantsFilter::Type::Members:
case DialogParticipantsFilter::Type::Mention:
user_ids.push_back(my_user_id);
if (peer_user_id.is_valid() && peer_user_id != my_user_id) {
user_ids.push_back(peer_user_id);
}
break;
case DialogParticipantsFilter::Type::Restricted:
break;
case DialogParticipantsFilter::Type::Banned:
break;
case DialogParticipantsFilter::Type::Bots:
if (td_->auth_manager_->is_bot()) {
user_ids.push_back(my_user_id);
}
if (peer_user_id.is_valid() && td_->contacts_manager_->is_user_bot(peer_user_id) && peer_user_id != my_user_id) {
user_ids.push_back(peer_user_id);
}
break;
default:
UNREACHABLE();
}
auto result = td_->contacts_manager_->search_among_users(user_ids, query, limit);
return {result.first, transform(result.second, [&](UserId user_id) {
return DialogParticipant(user_id,
user_id == my_user_id && peer_user_id.is_valid() ? peer_user_id : my_user_id, 0,
DialogParticipantStatus::Member());
})};
}
void MessagesManager::search_dialog_participants(DialogId dialog_id, const string &query, int32 limit,
DialogParticipantsFilter filter, bool without_bot_info,
Promise<DialogParticipants> &&promise) {
LOG(INFO) << "Receive searchChatMembers request to search for \"" << query << "\" in " << dialog_id << " with filter "
<< filter;
if (!have_dialog_force(dialog_id)) {
return promise.set_error(Status::Error(3, "Chat not found"));
}
if (limit < 0) {
return promise.set_error(Status::Error(3, "Parameter limit must be non-negative"));
}
switch (dialog_id.get_type()) {
case DialogType::User:
promise.set_value(search_private_chat_participants(td_->contacts_manager_->get_my_id(), dialog_id.get_user_id(),
query, limit, filter));
return;
case DialogType::Chat:
return td_->contacts_manager_->search_chat_participants(dialog_id.get_chat_id(), query, limit, filter,
std::move(promise));
case DialogType::Channel: {
tl_object_ptr<td_api::SupergroupMembersFilter> request_filter;
string additional_query;
int32 additional_limit = 0;
switch (filter.type) {
case DialogParticipantsFilter::Type::Contacts:
request_filter = td_api::make_object<td_api::supergroupMembersFilterContacts>();
break;
case DialogParticipantsFilter::Type::Administrators:
request_filter = td_api::make_object<td_api::supergroupMembersFilterAdministrators>();
break;
case DialogParticipantsFilter::Type::Members:
request_filter = td_api::make_object<td_api::supergroupMembersFilterSearch>(query);
break;
case DialogParticipantsFilter::Type::Restricted:
request_filter = td_api::make_object<td_api::supergroupMembersFilterRestricted>(query);
break;
case DialogParticipantsFilter::Type::Banned:
request_filter = td_api::make_object<td_api::supergroupMembersFilterBanned>(query);
break;
case DialogParticipantsFilter::Type::Mention:
request_filter =
td_api::make_object<td_api::supergroupMembersFilterMention>(query, filter.top_thread_message_id.get());
break;
case DialogParticipantsFilter::Type::Bots:
request_filter = td_api::make_object<td_api::supergroupMembersFilterBots>();
break;
default:
UNREACHABLE();
}
switch (filter.type) {
case DialogParticipantsFilter::Type::Contacts:
case DialogParticipantsFilter::Type::Administrators:
case DialogParticipantsFilter::Type::Bots:
additional_query = query;
additional_limit = limit;
limit = 100;
break;
case DialogParticipantsFilter::Type::Members:
case DialogParticipantsFilter::Type::Restricted:
case DialogParticipantsFilter::Type::Banned:
case DialogParticipantsFilter::Type::Mention:
// query is passed to the server request
break;
default:
UNREACHABLE();
}
return td_->contacts_manager_->get_channel_participants(dialog_id.get_channel_id(), std::move(request_filter),
std::move(additional_query), 0, limit, additional_limit,
without_bot_info, std::move(promise));
}
case DialogType::SecretChat: {
auto peer_user_id = td_->contacts_manager_->get_secret_chat_user_id(dialog_id.get_secret_chat_id());
promise.set_value(
search_private_chat_participants(td_->contacts_manager_->get_my_id(), peer_user_id, query, limit, filter));
return;
}
case DialogType::None:
default:
UNREACHABLE();
promise.set_error(Status::Error(500, "Wrong chat type"));
}
}
vector<DialogAdministrator> MessagesManager::get_dialog_administrators(DialogId dialog_id, int left_tries,
Promise<Unit> &&promise) {
LOG(INFO) << "Receive GetChatAdministrators request in " << dialog_id;
if (!have_dialog_force(dialog_id)) {
promise.set_error(Status::Error(3, "Chat not found"));
return {};
}
switch (dialog_id.get_type()) {
case DialogType::User:
case DialogType::SecretChat:
promise.set_value(Unit());
break;
case DialogType::Chat:
case DialogType::Channel:
return td_->contacts_manager_->get_dialog_administrators(dialog_id, left_tries, std::move(promise));
case DialogType::None:
default:
UNREACHABLE();
promise.set_error(Status::Error(500, "Wrong chat type"));
}
return {};
}
tl_object_ptr<telegram_api::channelAdminLogEventsFilter> MessagesManager::get_channel_admin_log_events_filter(
const tl_object_ptr<td_api::chatEventLogFilters> &filters) {
if (filters == nullptr) {

View File

@ -10,7 +10,6 @@
#include "td/telegram/ChannelId.h"
#include "td/telegram/Dependencies.h"
#include "td/telegram/DialogAction.h"
#include "td/telegram/DialogAdministrator.h"
#include "td/telegram/DialogDate.h"
#include "td/telegram/DialogDb.h"
#include "td/telegram/DialogFilterId.h"
@ -478,25 +477,6 @@ class MessagesManager : public Actor {
void unpin_all_dialog_messages(DialogId dialog_id, Promise<Unit> &&promise);
void add_dialog_participant(DialogId dialog_id, UserId user_id, int32 forward_limit, Promise<Unit> &&promise);
void add_dialog_participants(DialogId dialog_id, const vector<UserId> &user_ids, Promise<Unit> &&promise);
void set_dialog_participant_status(DialogId dialog_id, UserId user_id,
const tl_object_ptr<td_api::ChatMemberStatus> &chat_member_status,
Promise<Unit> &&promise);
void ban_dialog_participant(DialogId dialog_id, UserId user_id, int32 banned_until_date, bool revoke_messages,
Promise<Unit> &&promise);
DialogParticipant get_dialog_participant(DialogId dialog_id, UserId user_id, int64 &random_id, bool force,
Promise<Unit> &&promise);
void search_dialog_participants(DialogId dialog_id, const string &query, int32 limit, DialogParticipantsFilter filter,
bool without_bot_info, Promise<DialogParticipants> &&promise);
vector<DialogAdministrator> get_dialog_administrators(DialogId dialog_id, int left_tries, Promise<Unit> &&promise);
void get_dialog_info_full(DialogId dialog_id, Promise<Unit> &&promise);
int64 get_dialog_event_log(DialogId dialog_id, const string &query, int64 from_event_id, int32 limit,
@ -2535,9 +2515,6 @@ class MessagesManager : public Actor {
DialogFolder *get_dialog_folder(FolderId folder_id);
const DialogFolder *get_dialog_folder(FolderId folder_id) const;
DialogParticipants search_private_chat_participants(UserId my_user_id, UserId peer_user_id, const string &query,
int32 limit, DialogParticipantsFilter filter) const;
static unique_ptr<Message> *treap_find_message(unique_ptr<Message> *v, MessageId message_id);
static const unique_ptr<Message> *treap_find_message(const unique_ptr<Message> *v, MessageId message_id);

View File

@ -1946,7 +1946,7 @@ class GetChatMemberRequest : public RequestActor<> {
DialogParticipant dialog_participant_;
void do_run(Promise<Unit> &&promise) override {
dialog_participant_ = td->messages_manager_->get_dialog_participant(dialog_id_, user_id_, random_id_,
dialog_participant_ = td->contacts_manager_->get_dialog_participant(dialog_id_, user_id_, random_id_,
get_tries() < 3, std::move(promise));
}
@ -1970,7 +1970,7 @@ class GetChatAdministratorsRequest : public RequestActor<> {
vector<DialogAdministrator> administrators_;
void do_run(Promise<Unit> &&promise) override {
administrators_ = td->messages_manager_->get_dialog_administrators(dialog_id_, get_tries(), std::move(promise));
administrators_ = td->contacts_manager_->get_dialog_administrators(dialog_id_, get_tries(), std::move(promise));
}
void do_send_result() override {
@ -6208,7 +6208,7 @@ void Td::on_request(uint64 id, const td_api::unpinAllChatMessages &request) {
void Td::on_request(uint64 id, const td_api::joinChat &request) {
CHECK_IS_USER();
CREATE_OK_REQUEST_PROMISE();
messages_manager_->add_dialog_participant(DialogId(request.chat_id_), contacts_manager_->get_my_id(), 0,
contacts_manager_->add_dialog_participant(DialogId(request.chat_id_), contacts_manager_->get_my_id(), 0,
std::move(promise));
}
@ -6227,14 +6227,14 @@ void Td::on_request(uint64 id, const td_api::leaveChat &request) {
td_api::make_object<td_api::chatMemberStatusCreator>(status.get_rank(), status.is_anonymous(), false);
}
}
messages_manager_->set_dialog_participant_status(dialog_id, contacts_manager_->get_my_id(), std::move(new_status),
contacts_manager_->set_dialog_participant_status(dialog_id, contacts_manager_->get_my_id(), std::move(new_status),
std::move(promise));
}
void Td::on_request(uint64 id, const td_api::addChatMember &request) {
CHECK_IS_USER();
CREATE_OK_REQUEST_PROMISE();
messages_manager_->add_dialog_participant(DialogId(request.chat_id_), UserId(request.user_id_),
contacts_manager_->add_dialog_participant(DialogId(request.chat_id_), UserId(request.user_id_),
request.forward_limit_, std::move(promise));
}
@ -6245,19 +6245,19 @@ void Td::on_request(uint64 id, const td_api::addChatMembers &request) {
for (auto &user_id : request.user_ids_) {
user_ids.emplace_back(user_id);
}
messages_manager_->add_dialog_participants(DialogId(request.chat_id_), user_ids, std::move(promise));
contacts_manager_->add_dialog_participants(DialogId(request.chat_id_), user_ids, std::move(promise));
}
void Td::on_request(uint64 id, td_api::setChatMemberStatus &request) {
CREATE_OK_REQUEST_PROMISE();
messages_manager_->set_dialog_participant_status(DialogId(request.chat_id_), UserId(request.user_id_),
contacts_manager_->set_dialog_participant_status(DialogId(request.chat_id_), UserId(request.user_id_),
request.status_, std::move(promise));
}
void Td::on_request(uint64 id, const td_api::banChatMember &request) {
CHECK_IS_USER();
CREATE_OK_REQUEST_PROMISE();
messages_manager_->ban_dialog_participant(DialogId(request.chat_id_), UserId(request.user_id_),
contacts_manager_->ban_dialog_participant(DialogId(request.chat_id_), UserId(request.user_id_),
request.banned_until_date_, request.revoke_messages_, std::move(promise));
}
@ -6298,7 +6298,7 @@ void Td::on_request(uint64 id, td_api::searchChatMembers &request) {
promise.set_value(result.ok().get_chat_members_object(td));
}
});
messages_manager_->search_dialog_participants(DialogId(request.chat_id_), request.query_, request.limit_,
contacts_manager_->search_dialog_participants(DialogId(request.chat_id_), request.query_, request.limit_,
get_dialog_participants_filter(request.filter_), false,
std::move(query_promise));
}