From c4504af3400de572618a6c1bf95824ebe4b906bf Mon Sep 17 00:00:00 2001 From: levlam Date: Mon, 8 May 2023 14:15:32 +0300 Subject: [PATCH] Explicitly pass Td to UserPrivacySettingRule. --- td/telegram/PrivacyManager.cpp | 54 +++++++++++--------- td/telegram/UserPrivacySettingRule.cpp | 71 +++++++++++++------------- td/telegram/UserPrivacySettingRule.h | 26 +++++----- 3 files changed, 79 insertions(+), 72 deletions(-) diff --git a/td/telegram/PrivacyManager.cpp b/td/telegram/PrivacyManager.cpp index c56f22ff9..6248e9805 100644 --- a/td/telegram/PrivacyManager.cpp +++ b/td/telegram/PrivacyManager.cpp @@ -169,7 +169,7 @@ void PrivacyManager::get_privacy(tl_object_ptr key, auto user_privacy_setting = r_user_privacy_setting.move_as_ok(); auto &info = get_info(user_privacy_setting); if (info.is_synchronized) { - return promise.set_value(info.rules.get_user_privacy_setting_rules_object()); + return promise.set_value(info.rules.get_user_privacy_setting_rules_object(G()->td().get_actor_unsafe())); } info.get_promises.push_back(std::move(promise)); if (info.get_promises.size() > 1u) { @@ -185,7 +185,8 @@ void PrivacyManager::get_privacy(tl_object_ptr key, TRY_RESULT(net_query, std::move(x_net_query)); TRY_RESULT(rules, fetch_result(std::move(net_query))); LOG(INFO) << "Receive " << to_string(rules); - return UserPrivacySettingRules::get_user_privacy_setting_rules(std::move(rules)); + return UserPrivacySettingRules::get_user_privacy_setting_rules(G()->td().get_actor_unsafe(), + std::move(rules)); }()); })); } @@ -193,37 +194,42 @@ void PrivacyManager::get_privacy(tl_object_ptr key, void PrivacyManager::set_privacy(tl_object_ptr key, tl_object_ptr rules, Promise promise) { TRY_RESULT_PROMISE(promise, user_privacy_setting, UserPrivacySetting::get_user_privacy_setting(std::move(key))); - TRY_RESULT_PROMISE(promise, privacy_rules, UserPrivacySettingRules::get_user_privacy_setting_rules(std::move(rules))); + TRY_RESULT_PROMISE( + promise, privacy_rules, + UserPrivacySettingRules::get_user_privacy_setting_rules(G()->td().get_actor_unsafe(), std::move(rules))); auto &info = get_info(user_privacy_setting); if (info.has_set_query) { // TODO cancel previous query return promise.set_error(Status::Error(400, "Another set_privacy query is active")); } - auto net_query = G()->net_query_creator().create(telegram_api::account_setPrivacy( - user_privacy_setting.get_input_privacy_key(), privacy_rules.get_input_privacy_rules())); + auto net_query = G()->net_query_creator().create( + telegram_api::account_setPrivacy(user_privacy_setting.get_input_privacy_key(), + privacy_rules.get_input_privacy_rules(G()->td().get_actor_unsafe()))); info.has_set_query = true; - send_with_promise( - std::move(net_query), PromiseCreator::lambda([this, user_privacy_setting, promise = std::move(promise)]( - Result x_net_query) mutable { - promise.set_result([&]() -> Result { - get_info(user_privacy_setting).has_set_query = false; - TRY_RESULT(net_query, std::move(x_net_query)); - TRY_RESULT(rules, fetch_result(std::move(net_query))); - LOG(INFO) << "Receive " << to_string(rules); - TRY_RESULT(privacy_rules, UserPrivacySettingRules::get_user_privacy_setting_rules(std::move(rules))); - do_update_privacy(user_privacy_setting, std::move(privacy_rules), true); - return Unit(); - }()); - })); + send_with_promise(std::move(net_query), + PromiseCreator::lambda([this, user_privacy_setting, + promise = std::move(promise)](Result x_net_query) mutable { + promise.set_result([&]() -> Result { + get_info(user_privacy_setting).has_set_query = false; + TRY_RESULT(net_query, std::move(x_net_query)); + TRY_RESULT(rules, fetch_result(std::move(net_query))); + LOG(INFO) << "Receive " << to_string(rules); + TRY_RESULT(privacy_rules, UserPrivacySettingRules::get_user_privacy_setting_rules( + G()->td().get_actor_unsafe(), std::move(rules))); + do_update_privacy(user_privacy_setting, std::move(privacy_rules), true); + return Unit(); + }()); + })); } void PrivacyManager::update_privacy(tl_object_ptr update) { CHECK(update != nullptr); CHECK(update->key_ != nullptr); UserPrivacySetting user_privacy_setting(*update->key_); - auto r_privacy_rules = UserPrivacySettingRules::get_user_privacy_setting_rules(std::move(update->rules_)); + auto r_privacy_rules = + UserPrivacySettingRules::get_user_privacy_setting_rules(G()->td().get_actor_unsafe(), std::move(update->rules_)); if (r_privacy_rules.is_error()) { LOG(INFO) << "Skip updatePrivacy: " << r_privacy_rules.error().message(); auto &info = get_info(user_privacy_setting); @@ -242,7 +248,7 @@ void PrivacyManager::on_get_result(UserPrivacySetting user_privacy_setting, if (r_privacy_rules.is_error()) { promise.set_error(r_privacy_rules.error().clone()); } else { - promise.set_value(r_privacy_rules.ok().get_user_privacy_setting_rules_object()); + promise.set_value(r_privacy_rules.ok().get_user_privacy_setting_rules_object(G()->td().get_actor_unsafe())); } } if (r_privacy_rules.is_ok()) { @@ -286,10 +292,10 @@ void PrivacyManager::do_update_privacy(UserPrivacySetting user_privacy_setting, } info.rules = std::move(privacy_rules); - send_closure( - G()->td(), &Td::send_update, - make_tl_object(user_privacy_setting.get_user_privacy_setting_object(), - info.rules.get_user_privacy_setting_rules_object())); + send_closure(G()->td(), &Td::send_update, + make_tl_object( + user_privacy_setting.get_user_privacy_setting_object(), + info.rules.get_user_privacy_setting_rules_object(G()->td().get_actor_unsafe()))); } } diff --git a/td/telegram/UserPrivacySettingRule.cpp b/td/telegram/UserPrivacySettingRule.cpp index b81f09b61..9f51b44bd 100644 --- a/td/telegram/UserPrivacySettingRule.cpp +++ b/td/telegram/UserPrivacySettingRule.cpp @@ -10,7 +10,6 @@ #include "td/telegram/ChatId.h" #include "td/telegram/ContactsManager.h" #include "td/telegram/DialogId.h" -#include "td/telegram/Global.h" #include "td/telegram/MessagesManager.h" #include "td/telegram/Td.h" @@ -21,9 +20,8 @@ namespace td { -void UserPrivacySettingRule::set_chat_ids(const vector &dialog_ids) { +void UserPrivacySettingRule::set_chat_ids(Td *td, const vector &dialog_ids) { chat_ids_.clear(); - auto td = G()->td().get_actor_unsafe(); for (auto dialog_id_int : dialog_ids) { DialogId dialog_id(dialog_id_int); if (!td->messages_manager_->have_dialog_force(dialog_id, "UserPrivacySettingRule::set_chat_ids")) { @@ -50,7 +48,7 @@ void UserPrivacySettingRule::set_chat_ids(const vector &dialog_ids) { } } -UserPrivacySettingRule::UserPrivacySettingRule(const td_api::UserPrivacySettingRule &rule) { +UserPrivacySettingRule::UserPrivacySettingRule(Td *td, const td_api::UserPrivacySettingRule &rule) { switch (rule.get_id()) { case td_api::userPrivacySettingRuleAllowContacts::ID: type_ = Type::AllowContacts; @@ -67,7 +65,7 @@ UserPrivacySettingRule::UserPrivacySettingRule(const td_api::UserPrivacySettingR break; case td_api::userPrivacySettingRuleAllowChatMembers::ID: type_ = Type::AllowChatParticipants; - set_chat_ids(static_cast(rule).chat_ids_); + set_chat_ids(td, static_cast(rule).chat_ids_); break; case td_api::userPrivacySettingRuleRestrictContacts::ID: type_ = Type::RestrictContacts; @@ -82,11 +80,12 @@ UserPrivacySettingRule::UserPrivacySettingRule(const td_api::UserPrivacySettingR break; case td_api::userPrivacySettingRuleRestrictChatMembers::ID: type_ = Type::RestrictChatParticipants; - set_chat_ids(static_cast(rule).chat_ids_); + set_chat_ids(td, static_cast(rule).chat_ids_); break; default: UNREACHABLE(); } + td::remove_if(user_ids_, [](UserId user_id) { return !user_id.is_valid(); }); } UserPrivacySettingRule::UserPrivacySettingRule(const telegram_api::PrivacyRule &rule) { @@ -127,8 +126,8 @@ UserPrivacySettingRule::UserPrivacySettingRule(const telegram_api::PrivacyRule & } } -td_api::object_ptr UserPrivacySettingRule::get_user_privacy_setting_rule_object() - const { +td_api::object_ptr UserPrivacySettingRule::get_user_privacy_setting_rule_object( + Td *td) const { switch (type_) { case Type::AllowContacts: return make_tl_object(); @@ -137,23 +136,25 @@ td_api::object_ptr UserPrivacySettingRule::get_u case Type::AllowAll: return make_tl_object(); case Type::AllowUsers: - return make_tl_object(UserId::get_input_user_ids(user_ids_)); + return make_tl_object( + td->contacts_manager_->get_user_ids_object(user_ids_, "userPrivacySettingRuleAllowUsers")); case Type::AllowChatParticipants: - return make_tl_object(chat_ids_as_dialog_ids()); + return make_tl_object(chat_ids_as_dialog_ids(td)); case Type::RestrictContacts: return make_tl_object(); case Type::RestrictAll: return make_tl_object(); case Type::RestrictUsers: - return make_tl_object(UserId::get_input_user_ids(user_ids_)); + return make_tl_object( + td->contacts_manager_->get_user_ids_object(user_ids_, "userPrivacySettingRuleRestrictUsers")); case Type::RestrictChatParticipants: - return make_tl_object(chat_ids_as_dialog_ids()); + return make_tl_object(chat_ids_as_dialog_ids(td)); default: UNREACHABLE(); } } -telegram_api::object_ptr UserPrivacySettingRule::get_input_privacy_rule() const { +telegram_api::object_ptr UserPrivacySettingRule::get_input_privacy_rule(Td *td) const { switch (type_) { case Type::AllowContacts: return make_tl_object(); @@ -162,7 +163,7 @@ telegram_api::object_ptr UserPrivacySettingRule: case Type::AllowAll: return make_tl_object(); case Type::AllowUsers: - return make_tl_object(get_input_users()); + return make_tl_object(get_input_users(td)); case Type::AllowChatParticipants: return make_tl_object(vector{chat_ids_}); case Type::RestrictContacts: @@ -170,7 +171,7 @@ telegram_api::object_ptr UserPrivacySettingRule: case Type::RestrictAll: return make_tl_object(); case Type::RestrictUsers: - return make_tl_object(get_input_users()); + return make_tl_object(get_input_users(td)); case Type::RestrictChatParticipants: return make_tl_object(vector{chat_ids_}); default: @@ -179,10 +180,9 @@ telegram_api::object_ptr UserPrivacySettingRule: } Result UserPrivacySettingRule::get_user_privacy_setting_rule( - telegram_api::object_ptr rule) { + Td *td, telegram_api::object_ptr rule) { CHECK(rule != nullptr); UserPrivacySettingRule result(*rule); - auto td = G()->td().get_actor_unsafe(); for (auto user_id : result.user_ids_) { if (!td->contacts_manager_->have_user(user_id)) { return Status::Error(500, "Receive inaccessible user from the server"); @@ -203,10 +203,10 @@ Result UserPrivacySettingRule::get_user_privacy_setting_ return result; } -vector> UserPrivacySettingRule::get_input_users() const { +vector> UserPrivacySettingRule::get_input_users(Td *td) const { vector> result; for (auto user_id : user_ids_) { - auto r_input_user = G()->td().get_actor_unsafe()->contacts_manager_->get_input_user(user_id); + auto r_input_user = td->contacts_manager_->get_input_user(user_id); if (r_input_user.is_ok()) { result.push_back(r_input_user.move_as_ok()); } else { @@ -216,9 +216,8 @@ vector> UserPrivacySettingRule return result; } -vector UserPrivacySettingRule::chat_ids_as_dialog_ids() const { +vector UserPrivacySettingRule::chat_ids_as_dialog_ids(Td *td) const { vector result; - auto td = G()->td().get_actor_unsafe(); for (auto chat_id_int : chat_ids_) { ChatId chat_id(chat_id_int); DialogId dialog_id(chat_id); @@ -241,20 +240,20 @@ vector UserPrivacySettingRule::get_restricted_user_ids() const { } Result UserPrivacySettingRules::get_user_privacy_setting_rules( - telegram_api::object_ptr rules) { - G()->td().get_actor_unsafe()->contacts_manager_->on_get_users(std::move(rules->users_), "on get privacy rules"); - G()->td().get_actor_unsafe()->contacts_manager_->on_get_chats(std::move(rules->chats_), "on get privacy rules"); - return get_user_privacy_setting_rules(std::move(rules->rules_)); + Td *td, telegram_api::object_ptr rules) { + td->contacts_manager_->on_get_users(std::move(rules->users_), "on get privacy rules"); + td->contacts_manager_->on_get_chats(std::move(rules->chats_), "on get privacy rules"); + return get_user_privacy_setting_rules(td, std::move(rules->rules_)); } Result UserPrivacySettingRules::get_user_privacy_setting_rules( - vector> rules) { + Td *td, vector> rules) { UserPrivacySettingRules result; for (auto &rule : rules) { - TRY_RESULT(new_rule, UserPrivacySettingRule::get_user_privacy_setting_rule(std::move(rule))); + TRY_RESULT(new_rule, UserPrivacySettingRule::get_user_privacy_setting_rule(td, std::move(rule))); result.rules_.push_back(new_rule); } - if (!result.rules_.empty() && result.rules_.back().get_user_privacy_setting_rule_object()->get_id() == + if (!result.rules_.empty() && result.rules_.back().get_user_privacy_setting_rule_object(td)->get_id() == td_api::userPrivacySettingRuleRestrictAll::ID) { result.rules_.pop_back(); } @@ -262,7 +261,7 @@ Result UserPrivacySettingRules::get_user_privacy_settin } Result UserPrivacySettingRules::get_user_privacy_setting_rules( - td_api::object_ptr rules) { + Td *td, td_api::object_ptr rules) { if (rules == nullptr) { return Status::Error(400, "UserPrivacySettingRules must be non-empty"); } @@ -271,20 +270,20 @@ Result UserPrivacySettingRules::get_user_privacy_settin if (rule == nullptr) { return Status::Error(400, "UserPrivacySettingRule must be non-empty"); } - result.rules_.emplace_back(*rule); + result.rules_.emplace_back(td, *rule); } return result; } -td_api::object_ptr UserPrivacySettingRules::get_user_privacy_setting_rules_object() - const { +td_api::object_ptr UserPrivacySettingRules::get_user_privacy_setting_rules_object( + Td *td) const { return make_tl_object( - transform(rules_, [](const auto &rule) { return rule.get_user_privacy_setting_rule_object(); })); + transform(rules_, [td](const auto &rule) { return rule.get_user_privacy_setting_rule_object(td); })); } -vector> UserPrivacySettingRules::get_input_privacy_rules() - const { - auto result = transform(rules_, [](const auto &rule) { return rule.get_input_privacy_rule(); }); +vector> UserPrivacySettingRules::get_input_privacy_rules( + Td *td) const { + auto result = transform(rules_, [td](const auto &rule) { return rule.get_input_privacy_rule(td); }); if (!result.empty() && result.back()->get_id() == telegram_api::inputPrivacyValueDisallowAll::ID) { result.pop_back(); } diff --git a/td/telegram/UserPrivacySettingRule.h b/td/telegram/UserPrivacySettingRule.h index 4435bfdef..8fbd83c39 100644 --- a/td/telegram/UserPrivacySettingRule.h +++ b/td/telegram/UserPrivacySettingRule.h @@ -15,18 +15,20 @@ namespace td { +class Td; + class UserPrivacySettingRule { public: UserPrivacySettingRule() = default; - explicit UserPrivacySettingRule(const td_api::UserPrivacySettingRule &rule); + UserPrivacySettingRule(Td *td, const td_api::UserPrivacySettingRule &rule); static Result get_user_privacy_setting_rule( - telegram_api::object_ptr rule); + Td *td, telegram_api::object_ptr rule); - td_api::object_ptr get_user_privacy_setting_rule_object() const; + td_api::object_ptr get_user_privacy_setting_rule_object(Td *td) const; - telegram_api::object_ptr get_input_privacy_rule() const; + telegram_api::object_ptr get_input_privacy_rule(Td *td) const; bool operator==(const UserPrivacySettingRule &other) const { return type_ == other.type_ && user_ids_ == other.user_ids_ && chat_ids_ == other.chat_ids_; @@ -50,11 +52,11 @@ class UserPrivacySettingRule { vector user_ids_; vector chat_ids_; - vector> get_input_users() const; + vector> get_input_users(Td *td) const; - void set_chat_ids(const vector &dialog_ids); + void set_chat_ids(Td *td, const vector &dialog_ids); - vector chat_ids_as_dialog_ids() const; + vector chat_ids_as_dialog_ids(Td *td) const; explicit UserPrivacySettingRule(const telegram_api::PrivacyRule &rule); }; @@ -64,17 +66,17 @@ class UserPrivacySettingRules { UserPrivacySettingRules() = default; static Result get_user_privacy_setting_rules( - telegram_api::object_ptr rules); + Td *td, telegram_api::object_ptr rules); static Result get_user_privacy_setting_rules( - vector> rules); + Td *td, vector> rules); static Result get_user_privacy_setting_rules( - td_api::object_ptr rules); + Td *td, td_api::object_ptr rules); - td_api::object_ptr get_user_privacy_setting_rules_object() const; + td_api::object_ptr get_user_privacy_setting_rules_object(Td *td) const; - vector> get_input_privacy_rules() const; + vector> get_input_privacy_rules(Td *td) const; bool operator==(const UserPrivacySettingRules &other) const { return rules_ == other.rules_;