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

Move get_chat_ids_object and get_chats_object to DialogManager.

Browse Source
This commit is contained in:
levlam 2024-01-04 16:13:20 +03:00
parent ebda6f1364
commit 32898dbe88
31 changed files with 117 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
td/telegram/AutosaveManager.cpp
View File

@ -12,7 +12,6 @@
#include "td/telegram/DialogManager.h"
#include "td/telegram/Global.h"
#include "td/telegram/logevent/LogEvent.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/Td.h"
#include "td/telegram/TdDb.h"
#include "td/telegram/telegram_api.h"
@ -184,7 +183,7 @@ td_api::object_ptr<td_api::autosaveSettingsException>
AutosaveManager::DialogAutosaveSettings::get_autosave_settings_exception_object(const Td *td,
DialogId dialog_id) const {
return td_api::make_object<td_api::autosaveSettingsException>(
td->messages_manager_->get_chat_id_object(dialog_id, "autosaveSettingsException"),
td->dialog_manager_->get_chat_id_object(dialog_id, "autosaveSettingsException"),
get_scope_autosave_settings_object());
}
@ -424,7 +423,7 @@ void AutosaveManager::on_get_autosave_settings(
current_settings = std::move(new_settings);
send_update_autosave_settings(
td_api::make_object<td_api::autosaveSettingsScopeChat>(
td_->messages_manager_->get_chat_id_object(dialog_id, "autosaveSettingsScopeChat")),
td_->dialog_manager_->get_chat_id_object(dialog_id, "autosaveSettingsScopeChat")),
current_settings);
}
exception_dialog_ids.erase(dialog_id);
@ -433,7 +432,7 @@ void AutosaveManager::on_get_autosave_settings(
settings_.exceptions_.erase(dialog_id);
send_update_autosave_settings(
td_api::make_object<td_api::autosaveSettingsScopeChat>(
td_->messages_manager_->get_chat_id_object(dialog_id, "autosaveSettingsScopeChat 2")),
td_->dialog_manager_->get_chat_id_object(dialog_id, "autosaveSettingsScopeChat 2")),
DialogAutosaveSettings());
}

6
td/telegram/BoostManager.cpp
View File

@ -95,7 +95,7 @@ static td_api::object_ptr<td_api::chatBoostSlots> get_chat_boost_slots_object(
cooldown_until_date = 0;
}
slots.push_back(td_api::make_object<td_api::chatBoostSlot>(
my_boost->slot_, td->messages_manager_->get_chat_id_object(dialog_id, "GetMyBoostsQuery"), start_date,
my_boost->slot_, td->dialog_manager_->get_chat_id_object(dialog_id, "GetMyBoostsQuery"), start_date,
expiration_date, cooldown_until_date));
}
return td_api::make_object<td_api::chatBoostSlots>(std::move(slots));
@ -448,7 +448,7 @@ td_api::object_ptr<td_api::chatBoostLinkInfo> BoostManager::get_chat_boost_link_
DialogId dialog_id =
is_public ? td_->messages_manager_->resolve_dialog_username(info.username) : DialogId(info.channel_id);
return td_api::make_object<td_api::chatBoostLinkInfo>(
is_public, td_->messages_manager_->get_chat_id_object(dialog_id, "chatBoostLinkInfo"));
is_public, td_->dialog_manager_->get_chat_id_object(dialog_id, "chatBoostLinkInfo"));
}
void BoostManager::get_dialog_boosts(DialogId dialog_id, bool only_gift_codes, const string &offset, int32 limit,
@ -496,7 +496,7 @@ void BoostManager::on_update_dialog_boost(DialogId dialog_id, telegram_api::obje
send_closure(
G()->td(), &Td::send_update,
td_api::make_object<td_api::updateChatBoost>(
td_->messages_manager_->get_chat_id_object(dialog_id, "updateChatBoost"), std::move(chat_boost_object)));
td_->dialog_manager_->get_chat_id_object(dialog_id, "updateChatBoost"), std::move(chat_boost_object)));
}
} // namespace td

2
td/telegram/CallbackQueriesManager.cpp
View File

@ -195,7 +195,7 @@ void CallbackQueriesManager::on_new_query(int32 flags, int64 callback_query_id,
G()->td(), &Td::send_update,
td_api::make_object<td_api::updateNewCallbackQuery>(
callback_query_id, td_->contacts_manager_->get_user_id_object(sender_user_id, "updateNewCallbackQuery"),
td_->messages_manager_->get_chat_id_object(dialog_id, "updateNewCallbackQuery"), message_id.get(),
td_->dialog_manager_->get_chat_id_object(dialog_id, "updateNewCallbackQuery"), message_id.get(),
chat_instance, std::move(payload)));
}

20
td/telegram/ContactsManager.cpp
View File

@ -7411,7 +7411,7 @@ vector<td_api::object_ptr<td_api::chatNearby>> ContactsManager::get_chats_nearby
const vector<DialogNearby> &dialogs_nearby) const {
return transform(dialogs_nearby, [td = td_](const DialogNearby &dialog_nearby) {
return td_api::make_object<td_api::chatNearby>(
td->messages_manager_->get_chat_id_object(dialog_nearby.dialog_id, "chatNearby"), dialog_nearby.distance);
td->dialog_manager_->get_chat_id_object(dialog_nearby.dialog_id, "chatNearby"), dialog_nearby.distance);
});
}
@ -8990,7 +8990,7 @@ void ContactsManager::send_update_add_chat_members_privacy_forbidden(DialogId di
td_->dialog_manager_->force_create_dialog(dialog_id, "send_update_add_chat_members_privacy_forbidden");
send_closure(G()->td(), &Td::send_update,
td_api::make_object<td_api::updateAddChatMembersPrivacyForbidden>(
td_->messages_manager_->get_chat_id_object(dialog_id, "updateAddChatMembersPrivacyForbidden"),
td_->dialog_manager_->get_chat_id_object(dialog_id, "updateAddChatMembersPrivacyForbidden"),
get_user_ids_object(user_ids, source)));
}
@ -9972,8 +9972,8 @@ void ContactsManager::get_channel_recommendations(DialogId dialog_id, bool retur
if (are_suitable_recommended_dialogs(it->second)) {
auto next_reload_time = it->second.next_reload_time_;
if (chats_promise) {
chats_promise.set_value(td_->messages_manager_->get_chats_object(
it->second.total_count_, it->second.dialog_ids_, "get_channel_recommendations"));
chats_promise.set_value(td_->dialog_manager_->get_chats_object(it->second.total_count_, it->second.dialog_ids_,
"get_channel_recommendations"));
}
if (count_promise) {
count_promise.set_value(td_api::make_object<td_api::count>(it->second.total_count_));
@ -10060,8 +10060,8 @@ void ContactsManager::finish_load_channel_recommendations_queries(ChannelId chan
get_channel_recommendations_queries_.erase(it);
for (auto &promise : promises) {
if (promise) {
promise.set_value(td_->messages_manager_->get_chats_object(total_count, dialog_ids,
"finish_load_channel_recommendations_queries"));
promise.set_value(td_->dialog_manager_->get_chats_object(total_count, dialog_ids,
"finish_load_channel_recommendations_queries"));
}
}
}
@ -17568,7 +17568,7 @@ void ContactsManager::send_update_chat_member(DialogId dialog_id, UserId agent_u
td_->dialog_manager_->force_create_dialog(dialog_id, "send_update_chat_member", true);
send_closure(G()->td(), &Td::send_update,
td_api::make_object<td_api::updateChatMember>(
td_->messages_manager_->get_chat_id_object(dialog_id, "updateChatMember"),
td_->dialog_manager_->get_chat_id_object(dialog_id, "updateChatMember"),
get_user_id_object(agent_user_id, "send_update_chat_member"), date,
invite_link.get_chat_invite_link_object(this), via_dialog_filter_invite_link,
get_chat_member_object(old_dialog_participant, "send_update_chat_member old"),
@ -17722,10 +17722,10 @@ void ContactsManager::on_update_chat_invite_requester(DialogId dialog_id, UserId
send_closure(G()->td(), &Td::send_update,
td_api::make_object<td_api::updateNewChatJoinRequest>(
td_->messages_manager_->get_chat_id_object(dialog_id, "updateNewChatJoinRequest"),
td_->dialog_manager_->get_chat_id_object(dialog_id, "updateNewChatJoinRequest"),
td_api::make_object<td_api::chatJoinRequest>(
get_user_id_object(user_id, "on_update_chat_invite_requester"), date, about),
td_->messages_manager_->get_chat_id_object(user_dialog_id, "updateNewChatJoinRequest 2"),
td_->dialog_manager_->get_chat_id_object(user_dialog_id, "updateNewChatJoinRequest 2"),
invite_link.get_chat_invite_link_object(this)));
}
@ -20702,7 +20702,7 @@ tl_object_ptr<td_api::chatInviteLinkInfo> ContactsManager::get_chat_invite_link_
}
return td_api::make_object<td_api::chatInviteLinkInfo>(
td_->messages_manager_->get_chat_id_object(dialog_id, "chatInviteLinkInfo"), accessible_for, std::move(chat_type),
td_->dialog_manager_->get_chat_id_object(dialog_id, "chatInviteLinkInfo"), accessible_for, std::move(chat_type),
title, get_chat_photo_info_object(td_->file_manager_.get(), photo), accent_color_id_object, description,
participant_count, std::move(member_user_ids), creates_join_request, is_public, is_verified, is_scam, is_fake);
}

4
td/telegram/DialogEventLog.cpp
View File

@ -251,8 +251,8 @@ static td_api::object_ptr<td_api::ChatEventAction> get_chat_event_action_object(
return nullptr;
}
return td_api::make_object<td_api::chatEventLinkedChatChanged>(
td->messages_manager_->get_chat_id_object(old_linked_dialog_id, "chatEventLinkedChatChanged"),
td->messages_manager_->get_chat_id_object(new_linked_dialog_id, "chatEventLinkedChatChanged 2"));
td->dialog_manager_->get_chat_id_object(old_linked_dialog_id, "chatEventLinkedChatChanged"),
td->dialog_manager_->get_chat_id_object(new_linked_dialog_id, "chatEventLinkedChatChanged 2"));
}
case telegram_api::channelAdminLogEventActionChangeLocation::ID: {
auto action = move_tl_object_as<telegram_api::channelAdminLogEventActionChangeLocation>(action_ptr);

3
td/telegram/DialogFilterInviteLink.cpp
View File

@ -8,7 +8,6 @@
#include "td/telegram/DialogManager.h"
#include "td/telegram/LinkManager.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/Td.h"
#include "td/utils/logging.h"
@ -33,7 +32,7 @@ DialogFilterInviteLink::DialogFilterInviteLink(
td_api::object_ptr<td_api::chatFolderInviteLink> DialogFilterInviteLink::get_chat_folder_invite_link_object(
const Td *td) const {
return td_api::make_object<td_api::chatFolderInviteLink>(
invite_link_, title_, td->messages_manager_->get_chat_ids_object(dialog_ids_, "chatFolderInviteLink"));
invite_link_, title_, td->dialog_manager_->get_chat_ids_object(dialog_ids_, "chatFolderInviteLink"));
}
bool DialogFilterInviteLink::is_valid_invite_link(Slice invite_link) {

12
td/telegram/DialogFilterManager.cpp
View File

@ -400,7 +400,7 @@ class GetChatlistUpdatesQuery final : public Td::ResultHandler {
td_->contacts_manager_->on_get_users(std::move(ptr->users_), "GetChatlistUpdatesQuery");
td_->contacts_manager_->on_get_chats(std::move(ptr->chats_), "GetChatlistUpdatesQuery");
auto missing_dialog_ids = td_->messages_manager_->get_peers_dialog_ids(std::move(ptr->missing_peers_), true);
promise_.set_value(td_->messages_manager_->get_chats_object(-1, missing_dialog_ids, "GetChatlistUpdatesQuery"));
promise_.set_value(td_->dialog_manager_->get_chats_object(-1, missing_dialog_ids, "GetChatlistUpdatesQuery"));
}
void on_error(Status status) final {
@ -1711,7 +1711,7 @@ void DialogFilterManager::on_get_leave_dialog_filter_suggestions(
auto dialog_ids = td_->messages_manager_->get_peers_dialog_ids(std::move(peers));
td::remove_if(dialog_ids, [&](DialogId dialog_id) { return !dialog_filter->is_dialog_included(dialog_id); });
promise.set_value(td_->messages_manager_->get_chats_object(-1, dialog_ids, "on_get_leave_dialog_filter_suggestions"));
promise.set_value(td_->dialog_manager_->get_chats_object(-1, dialog_ids, "on_get_leave_dialog_filter_suggestions"));
}
void DialogFilterManager::reorder_dialog_filters(vector<DialogFilterId> dialog_filter_ids,
@ -1884,8 +1884,8 @@ void DialogFilterManager::do_get_dialogs_for_dialog_filter_invite_link(
return promise.set_error(Status::Error(400, "Chat folder not found"));
}
promise.set_value(td_->messages_manager_->get_chats_object(-1, dialog_filter->get_dialogs_for_invite_link(td_),
"do_get_dialogs_for_dialog_filter_invite_link"));
promise.set_value(td_->dialog_manager_->get_chats_object(-1, dialog_filter->get_dialogs_for_invite_link(td_),
"do_get_dialogs_for_dialog_filter_invite_link"));
}
void DialogFilterManager::create_dialog_filter_invite_link(
@ -2025,8 +2025,8 @@ void DialogFilterManager::on_get_chatlist_invite(
auto missing_dialog_ids = td_->messages_manager_->get_peers_dialog_ids(std::move(missing_peers), true);
auto already_dialog_ids = td_->messages_manager_->get_peers_dialog_ids(std::move(already_peers));
promise.set_value(td_api::make_object<td_api::chatFolderInviteLinkInfo>(
std::move(info), td_->messages_manager_->get_chat_ids_object(missing_dialog_ids, "chatFolderInviteLinkInfo 1"),
td_->messages_manager_->get_chat_ids_object(already_dialog_ids, "chatFolderInviteLinkInfo 1")));
std::move(info), td_->dialog_manager_->get_chat_ids_object(missing_dialog_ids, "chatFolderInviteLinkInfo 1"),
td_->dialog_manager_->get_chat_ids_object(already_dialog_ids, "chatFolderInviteLinkInfo 1")));
}
void DialogFilterManager::add_dialog_filter_by_invite_link(const string &invite_link, vector<DialogId> dialog_ids,

26
td/telegram/DialogManager.cpp
View File

@ -15,6 +15,9 @@
#include "td/telegram/Td.h"
#include "td/telegram/UserId.h"
#include "td/utils/algorithm.h"
#include "td/utils/misc.h"
namespace td {
DialogManager::DialogManager(Td *td, ActorShared<> parent) : td_(td), parent_(std::move(parent)) {
@ -165,7 +168,7 @@ bool DialogManager::have_dialog_force(DialogId dialog_id, const char *source) co
void DialogManager::force_create_dialog(DialogId dialog_id, const char *source, bool expect_no_access,
bool force_update_dialog_pos) {
return td_->messages_manager_->force_create_dialog(dialog_id, source, expect_no_access, force_update_dialog_pos);
td_->messages_manager_->force_create_dialog(dialog_id, source, expect_no_access, force_update_dialog_pos);
}
bool DialogManager::have_dialog_info(DialogId dialog_id) const {
@ -267,6 +270,27 @@ void DialogManager::reload_dialog_info_full(DialogId dialog_id, const char *sour
}
}
int64 DialogManager::get_chat_id_object(DialogId dialog_id, const char *source) const {
return td_->messages_manager_->get_chat_id_object(dialog_id, source);
}
vector<int64> DialogManager::get_chat_ids_object(const vector<DialogId> &dialog_ids, const char *source) const {
return transform(dialog_ids, [this, source](DialogId dialog_id) { return get_chat_id_object(dialog_id, source); });
}
td_api::object_ptr<td_api::chats> DialogManager::get_chats_object(int32 total_count, const vector<DialogId> &dialog_ids,
const char *source) const {
if (total_count == -1) {
total_count = narrow_cast<int32>(dialog_ids.size());
}
return td_api::make_object<td_api::chats>(total_count, get_chat_ids_object(dialog_ids, source));
}
td_api::object_ptr<td_api::chats> DialogManager::get_chats_object(const std::pair<int32, vector<DialogId>> &dialog_ids,
const char *source) const {
return get_chats_object(dialog_ids.first, dialog_ids.second, source);
}
td_api::object_ptr<td_api::ChatType> DialogManager::get_chat_type_object(DialogId dialog_id) const {
switch (dialog_id.get_type()) {
case DialogType::User:

10
td/telegram/DialogManager.h
View File

@ -64,6 +64,16 @@ class DialogManager final : public Actor {
void reload_dialog_info_full(DialogId dialog_id, const char *source);
int64 get_chat_id_object(DialogId dialog_id, const char *source) const;
vector<int64> get_chat_ids_object(const vector<DialogId> &dialog_ids, const char *source) const;
td_api::object_ptr<td_api::chats> get_chats_object(int32 total_count, const vector<DialogId> &dialog_ids,
const char *source) const;
td_api::object_ptr<td_api::chats> get_chats_object(const std::pair<int32, vector<DialogId>> &dialog_ids,
const char *source) const;
td_api::object_ptr<td_api::ChatType> get_chat_type_object(DialogId dialog_id) const;
NotificationSettingsScope get_dialog_notification_setting_scope(DialogId dialog_id) const;

2
td/telegram/ForumTopicManager.cpp
View File

@ -1167,7 +1167,7 @@ void ForumTopicManager::set_topic_info(DialogId dialog_id, Topic *topic, unique_
td_api::object_ptr<td_api::updateForumTopicInfo> ForumTopicManager::get_update_forum_topic_info(
DialogId dialog_id, const ForumTopicInfo *topic_info) const {
return td_api::make_object<td_api::updateForumTopicInfo>(
td_->messages_manager_->get_chat_id_object(dialog_id, "updateForumTopicInfo"),
td_->dialog_manager_->get_chat_id_object(dialog_id, "updateForumTopicInfo"),
topic_info->get_forum_topic_info_object(td_));
}

5
td/telegram/GiveawayParameters.cpp
View File

@ -12,7 +12,6 @@
#include "td/telegram/DialogId.h"
#include "td/telegram/DialogManager.h"
#include "td/telegram/Global.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/misc.h"
#include "td/telegram/OptionManager.h"
#include "td/telegram/Td.h"
@ -132,12 +131,12 @@ td_api::object_ptr<td_api::premiumGiveawayParameters> GiveawayParameters::get_pr
for (auto channel_id : additional_channel_ids_) {
DialogId dialog_id(channel_id);
td->dialog_manager_->force_create_dialog(dialog_id, "premiumGiveawayParameters", true);
chat_ids.push_back(td->messages_manager_->get_chat_id_object(dialog_id, "premiumGiveawayParameters"));
chat_ids.push_back(td->dialog_manager_->get_chat_id_object(dialog_id, "premiumGiveawayParameters"));
}
DialogId dialog_id(boosted_channel_id_);
td->dialog_manager_->force_create_dialog(dialog_id, "premiumGiveawayParameters", true);
return td_api::make_object<td_api::premiumGiveawayParameters>(
td->messages_manager_->get_chat_id_object(dialog_id, "premiumGiveawayParameters"), std::move(chat_ids), date_,
td->dialog_manager_->get_chat_id_object(dialog_id, "premiumGiveawayParameters"), std::move(chat_ids), date_,
only_new_subscribers_, winners_are_visible_, vector<string>(country_codes_), prize_description_);
}

3
td/telegram/MediaArea.cpp
View File

@ -10,6 +10,7 @@
#include "td/telegram/ContactsManager.h"
#include "td/telegram/Dependencies.h"
#include "td/telegram/DialogId.h"
#include "td/telegram/DialogManager.h"
#include "td/telegram/InlineQueriesManager.h"
#include "td/telegram/MessageId.h"
#include "td/telegram/MessagesManager.h"
@ -199,7 +200,7 @@ td_api::object_ptr<td_api::storyArea> MediaArea::get_story_area_object(
}
case Type::Message:
type = td_api::make_object<td_api::storyAreaTypeMessage>(
td->messages_manager_->get_chat_id_object(message_full_id_.get_dialog_id(), "storyAreaTypeMessage"),
td->dialog_manager_->get_chat_id_object(message_full_id_.get_dialog_id(), "storyAreaTypeMessage"),
message_full_id_.get_message_id().get());
break;
default:

9
td/telegram/MessageContent.cpp
View File

@ -55,7 +55,6 @@
#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/OptionManager.h"
#include "td/telegram/OrderInfo.h"
@ -6939,7 +6938,7 @@ tl_object_ptr<td_api::MessageContent> get_message_content_object(const MessageCo
} else {
auto invoice_dialog_id = m->invoice_dialog_id.is_valid() ? m->invoice_dialog_id : dialog_id;
return make_tl_object<td_api::messagePaymentSuccessful>(
td->messages_manager_->get_chat_id_object(invoice_dialog_id, "messagePaymentSuccessful"),
td->dialog_manager_->get_chat_id_object(invoice_dialog_id, "messagePaymentSuccessful"),
m->invoice_message_id.get(), m->currency, m->total_amount, m->is_recurring, m->is_first_recurring,
m->invoice_payload);
}
@ -7074,7 +7073,7 @@ tl_object_ptr<td_api::MessageContent> get_message_content_object(const MessageCo
if (td->auth_manager_->is_bot()) {
chat_id = m->shared_dialog_ids[0].get();
} else {
chat_id = td->messages_manager_->get_chat_id_object(m->shared_dialog_ids[0], "messageChatShared");
chat_id = td->dialog_manager_->get_chat_id_object(m->shared_dialog_ids[0], "messageChatShared");
}
return make_tl_object<td_api::messageChatShared>(chat_id, m->button_id);
}
@ -7091,7 +7090,7 @@ tl_object_ptr<td_api::MessageContent> get_message_content_object(const MessageCo
case MessageContentType::Story: {
const auto *m = static_cast<const MessageStory *>(content);
return td_api::make_object<td_api::messageStory>(
td->messages_manager_->get_chat_id_object(m->story_full_id.get_dialog_id(), "messageStory"),
td->dialog_manager_->get_chat_id_object(m->story_full_id.get_dialog_id(), "messageStory"),
m->story_full_id.get_story_id().get(), m->via_mention);
}
case MessageContentType::WriteAccessAllowedByRequest:
@ -7122,7 +7121,7 @@ tl_object_ptr<td_api::MessageContent> get_message_content_object(const MessageCo
case MessageContentType::GiveawayWinners: {
const auto *m = static_cast<const MessageGiveawayWinners *>(content);
return td_api::make_object<td_api::messagePremiumGiveawayWinners>(
td->messages_manager_->get_chat_id_object(DialogId(m->boosted_channel_id), "messagePremiumGiveawayWinners"),
td->dialog_manager_->get_chat_id_object(DialogId(m->boosted_channel_id), "messagePremiumGiveawayWinners"),
m->giveaway_message_id.get(), m->additional_dialog_count, m->winners_selection_date, m->only_new_subscribers,
m->was_refunded, m->month_count, m->prize_description, m->winner_count,
td->contacts_manager_->get_user_ids_object(m->winner_user_ids, "messagePremiumGiveawayWinners"),

5
td/telegram/MessageInputReplyTo.cpp
View File

@ -12,7 +12,6 @@
#include "td/telegram/DialogId.h"
#include "td/telegram/DialogManager.h"
#include "td/telegram/InputDialogId.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/misc.h"
#include "td/telegram/ServerMessageId.h"
#include "td/telegram/StoryId.h"
@ -143,7 +142,7 @@ telegram_api::object_ptr<telegram_api::InputReplyTo> MessageInputReplyTo::get_in
td_api::object_ptr<td_api::InputMessageReplyTo> MessageInputReplyTo::get_input_message_reply_to_object(Td *td) const {
if (story_full_id_.is_valid()) {
return td_api::make_object<td_api::inputMessageReplyToStory>(
td->messages_manager_->get_chat_id_object(story_full_id_.get_dialog_id(), "inputMessageReplyToStory"),
td->dialog_manager_->get_chat_id_object(story_full_id_.get_dialog_id(), "inputMessageReplyToStory"),
story_full_id_.get_story_id().get());
}
if (!message_id_.is_valid() && !message_id_.is_valid_scheduled()) {
@ -154,7 +153,7 @@ td_api::object_ptr<td_api::InputMessageReplyTo> MessageInputReplyTo::get_input_m
quote = td_api::make_object<td_api::inputTextQuote>(get_formatted_text_object(quote_, true, -1), quote_position_);
}
return td_api::make_object<td_api::inputMessageReplyToMessage>(
td->messages_manager_->get_chat_id_object(dialog_id_, "inputMessageReplyToMessage"), message_id_.get(),
td->dialog_manager_->get_chat_id_object(dialog_id_, "inputMessageReplyToMessage"), message_id_.get(),
std::move(quote));
}

5
td/telegram/MessageOrigin.cpp
View File

@ -11,7 +11,6 @@
#include "td/telegram/Dependencies.h"
#include "td/telegram/DialogManager.h"
#include "td/telegram/Global.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/ServerMessageId.h"
#include "td/telegram/Td.h"
@ -86,12 +85,12 @@ td_api::object_ptr<td_api::MessageOrigin> MessageOrigin::get_message_origin_obje
}
if (message_id_.is_valid()) {
return td_api::make_object<td_api::messageOriginChannel>(
td->messages_manager_->get_chat_id_object(sender_dialog_id_, "messageOriginChannel"), message_id_.get(),
td->dialog_manager_->get_chat_id_object(sender_dialog_id_, "messageOriginChannel"), message_id_.get(),
author_signature_);
}
if (sender_dialog_id_.is_valid()) {
return td_api::make_object<td_api::messageOriginChat>(
td->messages_manager_->get_chat_id_object(sender_dialog_id_, "messageOriginChat"),
td->dialog_manager_->get_chat_id_object(sender_dialog_id_, "messageOriginChat"),
sender_name_.empty() ? author_signature_ : sender_name_);
}
return td_api::make_object<td_api::messageOriginUser>(

4
td/telegram/MessageSender.cpp
View File

@ -22,7 +22,7 @@ td_api::object_ptr<td_api::MessageSender> get_message_sender_object_const(Td *td
const char *source) {
if (dialog_id.is_valid() && td->messages_manager_->have_dialog(dialog_id)) {
return td_api::make_object<td_api::messageSenderChat>(
td->messages_manager_->get_chat_id_object(dialog_id, "get_message_sender_object_const"));
td->dialog_manager_->get_chat_id_object(dialog_id, "get_message_sender_object_const"));
}
if (!user_id.is_valid()) {
// can happen only if the server sends a message with wrong sender
@ -78,7 +78,7 @@ td_api::object_ptr<td_api::MessageSender> get_min_message_sender_object(Td *td,
}
if (td->messages_manager_->have_dialog(dialog_id)) {
return td_api::make_object<td_api::messageSenderChat>(
td->messages_manager_->get_chat_id_object(dialog_id, "get_min_message_sender_object"));
td->dialog_manager_->get_chat_id_object(dialog_id, "get_min_message_sender_object"));
}
}
LOG(ERROR) << "Can't return unknown " << dialog_id << " from " << source;

20
td/telegram/MessagesManager.cpp
View File

@ -17066,7 +17066,8 @@ void MessagesManager::get_dialogs_from_list_impl(int64 task_id) {
if (!task_promise) {
dialog_ids.clear();
}
return task_promise.set_value(get_chats_object(total_count, dialog_ids, "get_dialogs_from_list_impl"));
return task_promise.set_value(
td_->dialog_manager_->get_chats_object(total_count, dialog_ids, "get_dialogs_from_list_impl"));
}
// nor the limit, nor the end of the list were reached; wait for the promise
}
@ -20553,10 +20554,6 @@ int64 MessagesManager::get_chat_id_object(DialogId dialog_id, const char *source
return dialog_id.get();
}
vector<int64> MessagesManager::get_chat_ids_object(const vector<DialogId> &dialog_ids, const char *source) const {
return transform(dialog_ids, [this, source](DialogId dialog_id) { return get_chat_id_object(dialog_id, source); });
}
td_api::object_ptr<td_api::ChatActionBar> MessagesManager::get_chat_action_bar_object(const Dialog *d) const {
CHECK(d != nullptr);
auto dialog_type = d->dialog_id.get_type();
@ -20679,19 +20676,6 @@ td_api::object_ptr<td_api::chat> MessagesManager::get_chat_object(DialogId dialo
return get_chat_object(d);
}
tl_object_ptr<td_api::chats> MessagesManager::get_chats_object(int32 total_count, const vector<DialogId> &dialog_ids,
const char *source) const {
if (total_count == -1) {
total_count = narrow_cast<int32>(dialog_ids.size());
}
return td_api::make_object<td_api::chats>(total_count, get_chat_ids_object(dialog_ids, source));
}
tl_object_ptr<td_api::chats> MessagesManager::get_chats_object(const std::pair<int32, vector<DialogId>> &dialog_ids,
const char *source) const {
return get_chats_object(dialog_ids.first, dialog_ids.second, source);
}
std::pair<bool, int32> MessagesManager::get_dialog_mute_until(DialogId dialog_id, const Dialog *d) const {
CHECK(!td_->auth_manager_->is_bot());
if (d == nullptr || !d->notification_settings.is_synchronized) {

8
td/telegram/MessagesManager.h
View File

@ -733,16 +733,8 @@ class MessagesManager final : public Actor {
int64 get_chat_id_object(DialogId dialog_id, const char *source) const;
vector<int64> get_chat_ids_object(const vector<DialogId> &dialog_ids, const char *source) const;
td_api::object_ptr<td_api::chat> get_chat_object(DialogId dialog_id);
tl_object_ptr<td_api::chats> get_chats_object(int32 total_count, const vector<DialogId> &dialog_ids,
const char *source) const;
tl_object_ptr<td_api::chats> get_chats_object(const std::pair<int32, vector<DialogId>> &dialog_ids,
const char *source) const;
tl_object_ptr<td_api::messages> get_dialog_history(DialogId dialog_id, MessageId from_message_id, int32 offset,
int32 limit, int left_tries, bool only_local,
Promise<Unit> &&promise);

26
td/telegram/NotificationManager.cpp
View File

@ -357,7 +357,7 @@ td_api::object_ptr<td_api::updateActiveNotifications> NotificationManager::get_u
std::reverse(notifications.begin(), notifications.end());
groups.push_back(td_api::make_object<td_api::notificationGroup>(
group.first.group_id.get(), get_notification_group_type_object(group.second.type),
td_->messages_manager_->get_chat_id_object(group.first.dialog_id, "updateActiveNotifications"),
td_->dialog_manager_->get_chat_id_object(group.first.dialog_id, "updateActiveNotifications"),
group.second.total_count, std::move(notifications)));
}
}
@ -733,7 +733,7 @@ void NotificationManager::add_notifications_to_group_begin(NotificationGroups::i
if (!added_notifications.empty()) {
add_update_notification_group(td_api::make_object<td_api::updateNotificationGroup>(
group_key.group_id.get(), get_notification_group_type_object(group.type),
td_->messages_manager_->get_chat_id_object(group_key.dialog_id, "updateNotificationGroup"), 0, 0,
td_->dialog_manager_->get_chat_id_object(group_key.dialog_id, "updateNotificationGroup"), 0, 0,
group.total_count, std::move(added_notifications), vector<int32>()));
}
}
@ -1461,9 +1461,9 @@ bool NotificationManager::do_flush_pending_notifications(NotificationGroupKey &g
if (!added_notifications.empty()) {
add_update_notification_group(td_api::make_object<td_api::updateNotificationGroup>(
group_key.group_id.get(), get_notification_group_type_object(group.type),
td_->messages_manager_->get_chat_id_object(group_key.dialog_id, "updateNotificationGroup 2"),
td_->messages_manager_->get_chat_id_object(pending_notifications[0].settings_dialog_id,
"updateNotificationGroup 3"),
td_->dialog_manager_->get_chat_id_object(group_key.dialog_id, "updateNotificationGroup 2"),
td_->dialog_manager_->get_chat_id_object(pending_notifications[0].settings_dialog_id,
"updateNotificationGroup 3"),
pending_notifications[0].ringtone_id, group.total_count, std::move(added_notifications),
std::move(removed_notification_ids)));
} else {
@ -1489,9 +1489,9 @@ td_api::object_ptr<td_api::updateNotificationGroup> NotificationManager::get_rem
}
return td_api::make_object<td_api::updateNotificationGroup>(
group_key.group_id.get(), get_notification_group_type_object(group.type),
td_->messages_manager_->get_chat_id_object(group_key.dialog_id, "updateNotificationGroup 4"),
td_->messages_manager_->get_chat_id_object(group_key.dialog_id, "updateNotificationGroup 10"), 0,
group.total_count, vector<td_api::object_ptr<td_api::notification>>(), std::move(removed_notification_ids));
td_->dialog_manager_->get_chat_id_object(group_key.dialog_id, "updateNotificationGroup 4"),
td_->dialog_manager_->get_chat_id_object(group_key.dialog_id, "updateNotificationGroup 10"), 0, group.total_count,
vector<td_api::object_ptr<td_api::notification>>(), std::move(removed_notification_ids));
}
void NotificationManager::send_remove_group_update(const NotificationGroupKey &group_key,
@ -1521,7 +1521,7 @@ void NotificationManager::send_add_group_update(const NotificationGroupKey &grou
if (!added_notifications.empty()) {
add_update_notification_group(td_api::make_object<td_api::updateNotificationGroup>(
group_key.group_id.get(), get_notification_group_type_object(group.type),
td_->messages_manager_->get_chat_id_object(group_key.dialog_id, "updateNotificationGroup 5"), 0, 0,
td_->dialog_manager_->get_chat_id_object(group_key.dialog_id, "updateNotificationGroup 5"), 0, 0,
group.total_count, std::move(added_notifications), vector<int32>()));
}
}
@ -1777,7 +1777,7 @@ void NotificationManager::on_notifications_removed(
// send update about empty invisible group anyway
add_update_notification_group(td_api::make_object<td_api::updateNotificationGroup>(
group_key.group_id.get(), get_notification_group_type_object(group.type),
td_->messages_manager_->get_chat_id_object(group_key.dialog_id, "updateNotificationGroup 6"), 0, 0, 0,
td_->dialog_manager_->get_chat_id_object(group_key.dialog_id, "updateNotificationGroup 6"), 0, 0, 0,
vector<td_api::object_ptr<td_api::notification>>(), vector<int32>()));
} else {
VLOG(notifications) << "There is no need to send updateNotificationGroup about " << group_key.group_id;
@ -1787,7 +1787,7 @@ void NotificationManager::on_notifications_removed(
// group is still visible
add_update_notification_group(td_api::make_object<td_api::updateNotificationGroup>(
group_key.group_id.get(), get_notification_group_type_object(group.type),
td_->messages_manager_->get_chat_id_object(group_key.dialog_id, "updateNotificationGroup 7"), 0, 0,
td_->dialog_manager_->get_chat_id_object(group_key.dialog_id, "updateNotificationGroup 7"), 0, 0,
group.total_count, std::move(added_notifications), std::move(removed_notification_ids)));
} else {
// group needs to be removed
@ -2602,8 +2602,8 @@ void NotificationManager::on_notification_group_size_max_changed() {
if (!is_destroyed_) {
auto update = td_api::make_object<td_api::updateNotificationGroup>(
group_key.group_id.get(), get_notification_group_type_object(group.type),
td_->messages_manager_->get_chat_id_object(group_key.dialog_id, "updateNotificationGroup 8"),
td_->messages_manager_->get_chat_id_object(group_key.dialog_id, "updateNotificationGroup 9"), 0,
td_->dialog_manager_->get_chat_id_object(group_key.dialog_id, "updateNotificationGroup 8"),
td_->dialog_manager_->get_chat_id_object(group_key.dialog_id, "updateNotificationGroup 9"), 0,
group.total_count, std::move(added_notifications), std::move(removed_notification_ids));
VLOG(notifications) << "Send " << as_notification_update(update.get());
send_closure(G()->td(), &Td::send_update, std::move(update));

2
td/telegram/NotificationSettingsManager.cpp
View File

@ -331,7 +331,7 @@ class GetStoryNotifySettingsExceptionsQuery final : public Td::ResultHandler {
for (auto &dialog_id : dialog_ids) {
td_->dialog_manager_->force_create_dialog(dialog_id, "GetStoryNotifySettingsExceptionsQuery");
}
auto chat_ids = td_->messages_manager_->get_chats_object(-1, dialog_ids, "GetStoryNotifySettingsExceptionsQuery");
auto chat_ids = td_->dialog_manager_->get_chats_object(-1, dialog_ids, "GetStoryNotifySettingsExceptionsQuery");
auto promise = PromiseCreator::lambda([promise = std::move(promise_), chat_ids = std::move(chat_ids)](
Result<Unit>) mutable { promise.set_value(std::move(chat_ids)); });
td_->updates_manager_->on_get_updates(std::move(updates_ptr), std::move(promise));

3
td/telegram/Premium.cpp
View File

@ -470,8 +470,7 @@ class GetGiveawayInfoQuery final : public Td::ResultHandler {
DialogId dialog_id(channel_id);
td_->dialog_manager_->force_create_dialog(dialog_id, "GetGiveawayInfoQuery");
return td_api::make_object<td_api::premiumGiveawayParticipantStatusAdministrator>(
td_->messages_manager_->get_chat_id_object(dialog_id,
"premiumGiveawayParticipantStatusAdministrator"));
td_->dialog_manager_->get_chat_id_object(dialog_id, "premiumGiveawayParticipantStatusAdministrator"));
}
}
if (!info->disallowed_country_.empty()) {

2
td/telegram/RepliedMessageInfo.cpp
View File

@ -315,7 +315,7 @@ td_api::object_ptr<td_api::messageReplyToMessage> RepliedMessageInfo::get_messag
} else {
CHECK(dialog_id.is_valid());
}
auto chat_id = td->messages_manager_->get_chat_id_object(dialog_id, "messageReplyToMessage");
auto chat_id = td->dialog_manager_->get_chat_id_object(dialog_id, "messageReplyToMessage");
if (message_id_ == MessageId()) {
chat_id = 0;
}

3
td/telegram/SponsoredMessageManager.cpp
View File

@ -13,7 +13,6 @@
#include "td/telegram/LinkManager.h"
#include "td/telegram/MessageContent.h"
#include "td/telegram/MessageEntity.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/net/NetQueryCreator.h"
#include "td/telegram/OptionManager.h"
#include "td/telegram/Photo.h"
@ -253,7 +252,7 @@ td_api::object_ptr<td_api::messageSponsor> SponsoredMessageManager::get_message_
<< sponsored_message.server_message_id.get());
}
type = td_api::make_object<td_api::messageSponsorTypePublicChannel>(
td_->messages_manager_->get_chat_id_object(sponsored_message.sponsor_dialog_id, "sponsoredMessage"),
td_->dialog_manager_->get_chat_id_object(sponsored_message.sponsor_dialog_id, "sponsoredMessage"),
std::move(link));
if (sponsored_message.show_dialog_photo) {
photo = get_chat_photo_info_object(td_->file_manager_.get(),

2
td/telegram/StickersManager.cpp
View File

@ -6934,7 +6934,7 @@ void StickersManager::send_update_animated_emoji_clicked(MessageFullId message_f
send_closure(G()->td(), &Td::send_update,
td_api::make_object<td_api::updateAnimatedEmojiMessageClicked>(
td_->messages_manager_->get_chat_id_object(dialog_id, "updateAnimatedEmojiMessageClicked"),
td_->dialog_manager_->get_chat_id_object(dialog_id, "updateAnimatedEmojiMessageClicked"),
message_full_id.get_message_id().get(), get_sticker_object(sticker_id, false, true)));
}

3
td/telegram/StoryForwardInfo.cpp
View File

@ -8,7 +8,6 @@
#include "td/telegram/Dependencies.h"
#include "td/telegram/DialogManager.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/Td.h"
#include "td/utils/logging.h"
@ -51,7 +50,7 @@ td_api::object_ptr<td_api::storyRepostInfo> StoryForwardInfo::get_story_repost_i
auto origin = [&]() -> td_api::object_ptr<td_api::StoryOrigin> {
if (dialog_id_.is_valid() && story_id_.is_valid()) {
return td_api::make_object<td_api::storyOriginPublicStory>(
td->messages_manager_->get_chat_id_object(dialog_id_, "storyOriginPublicStory"), story_id_.get());
td->dialog_manager_->get_chat_id_object(dialog_id_, "storyOriginPublicStory"), story_id_.get());
}
return td_api::make_object<td_api::storyOriginHiddenUser>(sender_name_);
}();

6
td/telegram/StoryManager.cpp
View File

@ -3208,7 +3208,7 @@ td_api::object_ptr<td_api::story> StoryManager::get_story_object(StoryFullId sto
story->is_update_sent_ = true;
return td_api::make_object<td_api::story>(
story_id.get(), td_->messages_manager_->get_chat_id_object(owner_dialog_id, "get_story_object"), story->date_,
story_id.get(), td_->dialog_manager_->get_chat_id_object(owner_dialog_id, "get_story_object"), story->date_,
is_being_sent, is_being_edited, is_edited, story->is_pinned_, is_visible_only_for_self, can_be_deleted,
can_be_edited, can_be_forwarded, can_be_replied, can_toggle_is_pinned, can_get_statistics, can_get_interactions,
has_expired_viewers, std::move(repost_info), std::move(interaction_info),
@ -3261,7 +3261,7 @@ td_api::object_ptr<td_api::chatActiveStories> StoryManager::get_chat_active_stor
}
}
return td_api::make_object<td_api::chatActiveStories>(
td_->messages_manager_->get_chat_id_object(owner_dialog_id, "updateChatActiveStories"),
td_->dialog_manager_->get_chat_id_object(owner_dialog_id, "updateChatActiveStories"),
story_list_id.get_story_list_object(), order, max_read_story_id.get(), std::move(stories));
}
@ -3630,7 +3630,7 @@ void StoryManager::on_delete_story(StoryFullId story_full_id) {
send_closure(
G()->td(), &Td::send_update,
td_api::make_object<td_api::updateStoryDeleted>(
td_->messages_manager_->get_chat_id_object(owner_dialog_id, "updateStoryDeleted"), story_id.get()));
td_->dialog_manager_->get_chat_id_object(owner_dialog_id, "updateStoryDeleted"), story_id.get()));
}
delete_story_files(story);
unregister_story_global_id(story);

18
td/telegram/Td.cpp
View File

@ -811,7 +811,7 @@ class SearchPublicChatsRequest final : public RequestActor<> {
}
void do_send_result() final {
send_result(td_->messages_manager_->get_chats_object(-1, dialog_ids_, "SearchPublicChatsRequest"));
send_result(td_->dialog_manager_->get_chats_object(-1, dialog_ids_, "SearchPublicChatsRequest"));
}
public:
@ -831,7 +831,7 @@ class SearchChatsRequest final : public RequestActor<> {
}
void do_send_result() final {
send_result(td_->messages_manager_->get_chats_object(dialog_ids_, "SearchChatsRequest"));
send_result(td_->dialog_manager_->get_chats_object(dialog_ids_, "SearchChatsRequest"));
}
public:
@ -851,7 +851,7 @@ class SearchChatsOnServerRequest final : public RequestActor<> {
}
void do_send_result() final {
send_result(td_->messages_manager_->get_chats_object(-1, dialog_ids_, "SearchChatsOnServerRequest"));
send_result(td_->dialog_manager_->get_chats_object(-1, dialog_ids_, "SearchChatsOnServerRequest"));
}
public:
@ -873,7 +873,7 @@ class GetGroupsInCommonRequest final : public RequestActor<> {
}
void do_send_result() final {
send_result(td_->messages_manager_->get_chats_object(dialog_ids_, "GetGroupsInCommonRequest"));
send_result(td_->dialog_manager_->get_chats_object(dialog_ids_, "GetGroupsInCommonRequest"));
}
public:
@ -890,7 +890,7 @@ class GetSuitableDiscussionChatsRequest final : public RequestActor<> {
}
void do_send_result() final {
send_result(td_->messages_manager_->get_chats_object(-1, dialog_ids_, "GetSuitableDiscussionChatsRequest"));
send_result(td_->dialog_manager_->get_chats_object(-1, dialog_ids_, "GetSuitableDiscussionChatsRequest"));
}
public:
@ -906,7 +906,7 @@ class GetInactiveSupergroupChatsRequest final : public RequestActor<> {
}
void do_send_result() final {
send_result(td_->messages_manager_->get_chats_object(-1, dialog_ids_, "GetInactiveSupergroupChatsRequest"));
send_result(td_->dialog_manager_->get_chats_object(-1, dialog_ids_, "GetInactiveSupergroupChatsRequest"));
}
public:
@ -925,7 +925,7 @@ class SearchRecentlyFoundChatsRequest final : public RequestActor<> {
}
void do_send_result() final {
send_result(td_->messages_manager_->get_chats_object(dialog_ids_, "SearchRecentlyFoundChatsRequest"));
send_result(td_->dialog_manager_->get_chats_object(dialog_ids_, "SearchRecentlyFoundChatsRequest"));
}
public:
@ -944,7 +944,7 @@ class GetRecentlyOpenedChatsRequest final : public RequestActor<> {
}
void do_send_result() final {
send_result(td_->messages_manager_->get_chats_object(dialog_ids_, "GetRecentlyOpenedChatsRequest"));
send_result(td_->dialog_manager_->get_chats_object(dialog_ids_, "GetRecentlyOpenedChatsRequest"));
}
public:
@ -1974,7 +1974,7 @@ class GetChatNotificationSettingsExceptionsRequest final : public RequestActor<>
void do_send_result() final {
send_result(
td_->messages_manager_->get_chats_object(-1, dialog_ids_, "GetChatNotificationSettingsExceptionsRequest"));
td_->dialog_manager_->get_chats_object(-1, dialog_ids_, "GetChatNotificationSettingsExceptionsRequest"));
}
public:

2
td/telegram/TopDialogManager.cpp
View File

@ -437,7 +437,7 @@ void TopDialogManager::on_load_dialogs(GetTopDialogsQuery &&query, vector<Dialog
}
query.promise.set_value(
td_->messages_manager_->get_chats_object(-1, std::move(result), "TopDialogManager::on_load_dialogs"));
td_->dialog_manager_->get_chats_object(-1, std::move(result), "TopDialogManager::on_load_dialogs"));
}
void TopDialogManager::do_get_top_peers() {

8
td/telegram/UpdatesManager.cpp
View File

@ -3032,9 +3032,9 @@ void UpdatesManager::process_qts_update(tl_object_ptr<telegram_api::Update> &&up
td_->dialog_manager_->force_create_dialog(dialog_id, "on_update_bot_message_reaction", true);
send_closure(G()->td(), &Td::send_update,
td_api::make_object<td_api::updateMessageReaction>(
td_->messages_manager_->get_chat_id_object(dialog_id, "updateMessageReaction"),
message_id.get(), get_message_sender_object(td_, actor_dialog_id, "updateMessageReaction"),
date, ReactionType::get_reaction_types_object(old_reaction_types),
td_->dialog_manager_->get_chat_id_object(dialog_id, "updateMessageReaction"), message_id.get(),
get_message_sender_object(td_, actor_dialog_id, "updateMessageReaction"), date,
ReactionType::get_reaction_types_object(old_reaction_types),
ReactionType::get_reaction_types_object(new_reaction_types)));
break;
}
@ -3061,7 +3061,7 @@ void UpdatesManager::process_qts_update(tl_object_ptr<telegram_api::Update> &&up
td_->dialog_manager_->force_create_dialog(dialog_id, "on_update_bot_message_reactions", true);
send_closure(G()->td(), &Td::send_update,
td_api::make_object<td_api::updateMessageReactions>(
td_->messages_manager_->get_chat_id_object(dialog_id, "updateMessageReactions"),
td_->dialog_manager_->get_chat_id_object(dialog_id, "updateMessageReactions"),
message_id.get(), date, std::move(message_reactions)));
break;
}

5
td/telegram/UserPrivacySettingRule.cpp
View File

@ -11,7 +11,6 @@
#include "td/telegram/ContactsManager.h"
#include "td/telegram/Dependencies.h"
#include "td/telegram/DialogManager.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/Td.h"
#include "td/utils/algorithm.h"
@ -167,7 +166,7 @@ td_api::object_ptr<td_api::UserPrivacySettingRule> UserPrivacySettingRule::get_u
td->contacts_manager_->get_user_ids_object(user_ids_, "userPrivacySettingRuleAllowUsers"));
case Type::AllowChatParticipants:
return make_tl_object<td_api::userPrivacySettingRuleAllowChatMembers>(
td->messages_manager_->get_chat_ids_object(dialog_ids_, "UserPrivacySettingRule"));
td->dialog_manager_->get_chat_ids_object(dialog_ids_, "UserPrivacySettingRule"));
case Type::RestrictContacts:
return make_tl_object<td_api::userPrivacySettingRuleRestrictContacts>();
case Type::RestrictAll:
@ -177,7 +176,7 @@ td_api::object_ptr<td_api::UserPrivacySettingRule> UserPrivacySettingRule::get_u
td->contacts_manager_->get_user_ids_object(user_ids_, "userPrivacySettingRuleRestrictUsers"));
case Type::RestrictChatParticipants:
return make_tl_object<td_api::userPrivacySettingRuleRestrictChatMembers>(
td->messages_manager_->get_chat_ids_object(dialog_ids_, "UserPrivacySettingRule"));
td->dialog_manager_->get_chat_ids_object(dialog_ids_, "UserPrivacySettingRule"));
default:
UNREACHABLE();
return nullptr;

2
td/telegram/WebPagesManager.cpp
View File

@ -1419,7 +1419,7 @@ tl_object_ptr<td_api::webPage> WebPagesManager::get_web_page_object(WebPageId we
web_page->document_.type == Document::Type::VoiceNote
? td_->voice_notes_manager_->get_voice_note_object(web_page->document_.file_id)
: nullptr,
td_->messages_manager_->get_chat_id_object(story_sender_dialog_id, "webPage"), story_id.get(),
td_->dialog_manager_->get_chat_id_object(story_sender_dialog_id, "webPage"), story_id.get(),
instant_view_version);
}