tdlight/td/telegram/BoostManager.cpp

509 lines
21 KiB
C++

//
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2024
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#include "td/telegram/BoostManager.h"
#include "td/telegram/AccessRights.h"
#include "td/telegram/AuthManager.h"
#include "td/telegram/ContactsManager.h"
#include "td/telegram/DialogManager.h"
#include "td/telegram/Global.h"
#include "td/telegram/LinkManager.h"
#include "td/telegram/MessageId.h"
#include "td/telegram/OptionManager.h"
#include "td/telegram/ServerMessageId.h"
#include "td/telegram/Td.h"
#include "td/telegram/telegram_api.h"
#include "td/telegram/ThemeManager.h"
#include "td/telegram/UserId.h"
#include "td/utils/algorithm.h"
#include "td/utils/buffer.h"
#include "td/utils/logging.h"
#include "td/utils/misc.h"
#include "td/utils/SliceBuilder.h"
namespace td {
static td_api::object_ptr<td_api::chatBoost> get_chat_boost_object(
Td *td, const telegram_api::object_ptr<telegram_api::boost> &boost) {
auto source = [&]() -> td_api::object_ptr<td_api::ChatBoostSource> {
if (boost->giveaway_) {
UserId user_id(boost->user_id_);
if (!user_id.is_valid() || boost->unclaimed_) {
user_id = UserId();
}
auto giveaway_message_id = MessageId(ServerMessageId(boost->giveaway_msg_id_));
if (!giveaway_message_id.is_valid()) {
giveaway_message_id = MessageId::min();
}
return td_api::make_object<td_api::chatBoostSourceGiveaway>(
td->contacts_manager_->get_user_id_object(user_id, "chatBoostSourceGiveaway"), boost->used_gift_slug_,
giveaway_message_id.get(), boost->unclaimed_);
}
if (boost->gift_) {
UserId user_id(boost->user_id_);
if (!user_id.is_valid()) {
return nullptr;
}
return td_api::make_object<td_api::chatBoostSourceGiftCode>(
td->contacts_manager_->get_user_id_object(user_id, "chatBoostSourceGiftCode"), boost->used_gift_slug_);
}
UserId user_id(boost->user_id_);
if (!user_id.is_valid()) {
return nullptr;
}
return td_api::make_object<td_api::chatBoostSourcePremium>(
td->contacts_manager_->get_user_id_object(user_id, "chatBoostSourcePremium"));
}();
if (source == nullptr) {
LOG(ERROR) << "Receive " << to_string(boost);
return nullptr;
}
return td_api::make_object<td_api::chatBoost>(boost->id_, max(boost->multiplier_, 1), std::move(source), boost->date_,
max(boost->expires_, 0));
}
static td_api::object_ptr<td_api::chatBoostSlots> get_chat_boost_slots_object(
Td *td, telegram_api::object_ptr<telegram_api::premium_myBoosts> &&my_boosts) {
td->contacts_manager_->on_get_users(std::move(my_boosts->users_), "GetMyBoostsQuery");
td->contacts_manager_->on_get_chats(std::move(my_boosts->chats_), "GetMyBoostsQuery");
vector<td_api::object_ptr<td_api::chatBoostSlot>> slots;
for (auto &my_boost : my_boosts->my_boosts_) {
auto expiration_date = my_boost->expires_;
if (expiration_date <= G()->unix_time()) {
continue;
}
auto start_date = max(0, my_boost->date_);
auto cooldown_until_date = max(0, my_boost->cooldown_until_date_);
DialogId dialog_id;
if (my_boost->peer_ != nullptr) {
dialog_id = DialogId(my_boost->peer_);
if (!dialog_id.is_valid()) {
LOG(ERROR) << "Receive " << to_string(my_boost);
continue;
}
}
if (dialog_id.is_valid()) {
td->dialog_manager_->force_create_dialog(dialog_id, "GetMyBoostsQuery", true);
} else {
start_date = 0;
cooldown_until_date = 0;
}
slots.push_back(td_api::make_object<td_api::chatBoostSlot>(
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));
}
class GetMyBoostsQuery final : public Td::ResultHandler {
Promise<td_api::object_ptr<td_api::chatBoostSlots>> promise_;
DialogId dialog_id_;
public:
explicit GetMyBoostsQuery(Promise<td_api::object_ptr<td_api::chatBoostSlots>> &&promise)
: promise_(std::move(promise)) {
}
void send() {
send_query(G()->net_query_creator().create(telegram_api::premium_getMyBoosts(), {{"me"}}));
}
void on_result(BufferSlice packet) final {
auto result_ptr = fetch_result<telegram_api::premium_getMyBoosts>(packet);
if (result_ptr.is_error()) {
return on_error(result_ptr.move_as_error());
}
auto result = result_ptr.move_as_ok();
LOG(DEBUG) << "Receive result for GetMyBoostsQuery: " << to_string(result);
promise_.set_value(get_chat_boost_slots_object(td_, std::move(result)));
}
void on_error(Status status) final {
promise_.set_error(std::move(status));
}
};
class GetBoostsStatusQuery final : public Td::ResultHandler {
Promise<td_api::object_ptr<td_api::chatBoostStatus>> promise_;
DialogId dialog_id_;
public:
explicit GetBoostsStatusQuery(Promise<td_api::object_ptr<td_api::chatBoostStatus>> &&promise)
: promise_(std::move(promise)) {
}
void send(DialogId dialog_id) {
dialog_id_ = dialog_id;
auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id_, AccessRights::Read);
CHECK(input_peer != nullptr);
send_query(
G()->net_query_creator().create(telegram_api::premium_getBoostsStatus(std::move(input_peer)), {{dialog_id}}));
}
void on_result(BufferSlice packet) final {
auto result_ptr = fetch_result<telegram_api::premium_getBoostsStatus>(packet);
if (result_ptr.is_error()) {
return on_error(result_ptr.move_as_error());
}
auto result = result_ptr.move_as_ok();
LOG(DEBUG) << "Receive result for GetBoostsStatusQuery: " << to_string(result);
if (result->level_ < 0 || result->current_level_boosts_ < 0 || result->boosts_ < result->current_level_boosts_ ||
(result->next_level_boosts_ != 0 && result->boosts_ >= result->next_level_boosts_)) {
LOG(ERROR) << "Receive invalid " << to_string(result);
if (result->level_ < 0) {
result->level_ = 0;
}
if (result->current_level_boosts_ < 0) {
result->current_level_boosts_ = 0;
}
if (result->boosts_ < result->current_level_boosts_) {
result->boosts_ = result->current_level_boosts_;
}
if (result->next_level_boosts_ != 0 && result->boosts_ >= result->next_level_boosts_) {
result->next_level_boosts_ = result->boosts_ + 1;
}
}
int32 premium_member_count = 0;
double premium_member_percentage = 0.0;
if (result->premium_audience_ != nullptr) {
premium_member_count = max(0, static_cast<int32>(result->premium_audience_->part_));
auto participant_count = max(static_cast<int32>(result->premium_audience_->total_), premium_member_count);
if (dialog_id_.get_type() == DialogType::Channel) {
td_->contacts_manager_->on_update_channel_participant_count(dialog_id_.get_channel_id(), participant_count);
}
if (participant_count > 0) {
premium_member_percentage = 100.0 * premium_member_count / participant_count;
}
}
auto giveaways = transform(std::move(result->prepaid_giveaways_),
[](telegram_api::object_ptr<telegram_api::prepaidGiveaway> giveaway) {
return td_api::make_object<td_api::prepaidPremiumGiveaway>(
giveaway->id_, giveaway->quantity_, giveaway->months_, giveaway->date_);
});
auto boost_count = max(0, result->boosts_);
auto gift_code_boost_count = clamp(result->gift_boosts_, 0, boost_count);
promise_.set_value(td_api::make_object<td_api::chatBoostStatus>(
result->boost_url_, std::move(result->my_boost_slots_), result->level_, gift_code_boost_count, boost_count,
result->current_level_boosts_, result->next_level_boosts_, premium_member_count, premium_member_percentage,
std::move(giveaways)));
}
void on_error(Status status) final {
td_->dialog_manager_->on_get_dialog_error(dialog_id_, status, "GetBoostsStatusQuery");
promise_.set_error(std::move(status));
}
};
class ApplyBoostQuery final : public Td::ResultHandler {
Promise<td_api::object_ptr<td_api::chatBoostSlots>> promise_;
DialogId dialog_id_;
public:
explicit ApplyBoostQuery(Promise<td_api::object_ptr<td_api::chatBoostSlots>> &&promise)
: promise_(std::move(promise)) {
}
void send(DialogId dialog_id, vector<int32> slot_ids) {
dialog_id_ = dialog_id;
auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id_, AccessRights::Read);
CHECK(input_peer != nullptr);
send_query(
G()->net_query_creator().create(telegram_api::premium_applyBoost(telegram_api::premium_applyBoost::SLOTS_MASK,
std::move(slot_ids), std::move(input_peer)),
{{dialog_id}, {"me"}}));
}
void on_result(BufferSlice packet) final {
auto result_ptr = fetch_result<telegram_api::premium_applyBoost>(packet);
if (result_ptr.is_error()) {
return on_error(result_ptr.move_as_error());
}
auto result = result_ptr.move_as_ok();
LOG(DEBUG) << "Receive result for ApplyBoostQuery: " << to_string(result);
promise_.set_value(get_chat_boost_slots_object(td_, std::move(result)));
}
void on_error(Status status) final {
td_->dialog_manager_->on_get_dialog_error(dialog_id_, status, "ApplyBoostQuery");
promise_.set_error(std::move(status));
}
};
class GetBoostsListQuery final : public Td::ResultHandler {
Promise<td_api::object_ptr<td_api::foundChatBoosts>> promise_;
DialogId dialog_id_;
public:
explicit GetBoostsListQuery(Promise<td_api::object_ptr<td_api::foundChatBoosts>> &&promise)
: promise_(std::move(promise)) {
}
void send(DialogId dialog_id, bool only_gift_codes, const string &offset, int32 limit) {
dialog_id_ = dialog_id;
auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id_, AccessRights::Read);
CHECK(input_peer != nullptr);
int32 flags = 0;
if (only_gift_codes) {
flags |= telegram_api::premium_getBoostsList::GIFTS_MASK;
}
send_query(G()->net_query_creator().create(
telegram_api::premium_getBoostsList(flags, false /*ignored*/, std::move(input_peer), offset, limit)));
}
void on_result(BufferSlice packet) final {
auto result_ptr = fetch_result<telegram_api::premium_getBoostsList>(packet);
if (result_ptr.is_error()) {
return on_error(result_ptr.move_as_error());
}
auto result = result_ptr.move_as_ok();
LOG(DEBUG) << "Receive result for GetBoostsListQuery: " << to_string(result);
td_->contacts_manager_->on_get_users(std::move(result->users_), "GetBoostsListQuery");
auto total_count = result->count_;
vector<td_api::object_ptr<td_api::chatBoost>> boosts;
for (auto &boost : result->boosts_) {
auto chat_boost_object = get_chat_boost_object(td_, boost);
if (chat_boost_object == nullptr || chat_boost_object->expiration_date_ <= G()->unix_time()) {
continue;
}
boosts.push_back(std::move(chat_boost_object));
}
promise_.set_value(
td_api::make_object<td_api::foundChatBoosts>(total_count, std::move(boosts), result->next_offset_));
}
void on_error(Status status) final {
td_->dialog_manager_->on_get_dialog_error(dialog_id_, status, "GetBoostsListQuery");
promise_.set_error(std::move(status));
}
};
class GetUserBoostsQuery final : public Td::ResultHandler {
Promise<td_api::object_ptr<td_api::foundChatBoosts>> promise_;
DialogId dialog_id_;
public:
explicit GetUserBoostsQuery(Promise<td_api::object_ptr<td_api::foundChatBoosts>> &&promise)
: promise_(std::move(promise)) {
}
void send(DialogId dialog_id, UserId user_id) {
dialog_id_ = dialog_id;
auto input_peer = td_->dialog_manager_->get_input_peer(dialog_id_, AccessRights::Read);
CHECK(input_peer != nullptr);
auto r_input_user = td_->contacts_manager_->get_input_user(user_id);
CHECK(r_input_user.is_ok());
send_query(G()->net_query_creator().create(
telegram_api::premium_getUserBoosts(std::move(input_peer), r_input_user.move_as_ok())));
}
void on_result(BufferSlice packet) final {
auto result_ptr = fetch_result<telegram_api::premium_getUserBoosts>(packet);
if (result_ptr.is_error()) {
return on_error(result_ptr.move_as_error());
}
auto result = result_ptr.move_as_ok();
LOG(DEBUG) << "Receive result for GetUserBoostsQuery: " << to_string(result);
td_->contacts_manager_->on_get_users(std::move(result->users_), "GetUserBoostsQuery");
auto total_count = result->count_;
vector<td_api::object_ptr<td_api::chatBoost>> boosts;
for (auto &boost : result->boosts_) {
auto chat_boost_object = get_chat_boost_object(td_, boost);
if (chat_boost_object == nullptr || chat_boost_object->expiration_date_ <= G()->unix_time()) {
continue;
}
boosts.push_back(std::move(chat_boost_object));
}
promise_.set_value(
td_api::make_object<td_api::foundChatBoosts>(total_count, std::move(boosts), result->next_offset_));
}
void on_error(Status status) final {
td_->dialog_manager_->on_get_dialog_error(dialog_id_, status, "GetUserBoostsQuery");
promise_.set_error(std::move(status));
}
};
BoostManager::BoostManager(Td *td, ActorShared<> parent) : td_(td), parent_(std::move(parent)) {
}
void BoostManager::tear_down() {
parent_.reset();
}
td_api::object_ptr<td_api::chatBoostLevelFeatures> BoostManager::get_chat_boost_level_features_object(
int32 level) const {
int32 actual_level =
clamp(level, 0, static_cast<int32>(td_->option_manager_->get_option_integer("chat_boost_level_max")));
auto theme_counts = td_->theme_manager_->get_dialog_boost_available_count(actual_level, false);
auto can_set_profile_background_custom_emoji =
actual_level >= td_->option_manager_->get_option_integer("channel_profile_bg_icon_level_min");
auto can_set_background_custom_emoji =
actual_level >= td_->option_manager_->get_option_integer("channel_bg_icon_level_min");
auto can_set_emoji_status =
actual_level >= td_->option_manager_->get_option_integer("channel_emoji_status_level_min");
auto can_set_custom_background =
actual_level >= td_->option_manager_->get_option_integer("channel_custom_wallpaper_level_min");
return td_api::make_object<td_api::chatBoostLevelFeatures>(
level, actual_level, actual_level, theme_counts.title_color_count_, theme_counts.profile_accent_color_count_,
can_set_profile_background_custom_emoji, theme_counts.accent_color_count_, can_set_background_custom_emoji,
can_set_emoji_status, theme_counts.chat_theme_count_, can_set_custom_background);
}
td_api::object_ptr<td_api::chatBoostFeatures> BoostManager::get_chat_boost_features_object() const {
vector<td_api::object_ptr<td_api::chatBoostLevelFeatures>> features;
for (int32 level = 1; level <= 10; level++) {
features.push_back(get_chat_boost_level_features_object(level));
}
auto get_min_boost_level = [&](Slice name) {
return narrow_cast<int32>(td_->option_manager_->get_option_integer(PSLICE() << "channel_" << name << "_level_min"));
};
return td_api::make_object<td_api::chatBoostFeatures>(
std::move(features), get_min_boost_level("profile_bg_icon"), get_min_boost_level("profile_bg_icon"),
get_min_boost_level("emoji_status"), get_min_boost_level("wallpaper"), get_min_boost_level("custom_wallpaper"));
}
void BoostManager::get_boost_slots(Promise<td_api::object_ptr<td_api::chatBoostSlots>> &&promise) {
td_->create_handler<GetMyBoostsQuery>(std::move(promise))->send();
}
void BoostManager::get_dialog_boost_status(DialogId dialog_id,
Promise<td_api::object_ptr<td_api::chatBoostStatus>> &&promise) {
if (!td_->dialog_manager_->have_dialog_force(dialog_id, "get_dialog_boost_status")) {
return promise.set_error(Status::Error(400, "Chat not found"));
}
if (!td_->dialog_manager_->have_input_peer(dialog_id, AccessRights::Read)) {
return promise.set_error(Status::Error(400, "Can't access the chat"));
}
td_->create_handler<GetBoostsStatusQuery>(std::move(promise))->send(dialog_id);
}
void BoostManager::boost_dialog(DialogId dialog_id, vector<int32> slot_ids,
Promise<td_api::object_ptr<td_api::chatBoostSlots>> &&promise) {
if (!td_->dialog_manager_->have_dialog_force(dialog_id, "get_dialog_boost_status")) {
return promise.set_error(Status::Error(400, "Chat not found"));
}
if (!td_->dialog_manager_->have_input_peer(dialog_id, AccessRights::Read)) {
return promise.set_error(Status::Error(400, "Can't access the chat"));
}
if (slot_ids.empty()) {
return get_boost_slots(std::move(promise));
}
td_->create_handler<ApplyBoostQuery>(std::move(promise))->send(dialog_id, slot_ids);
}
Result<std::pair<string, bool>> BoostManager::get_dialog_boost_link(DialogId dialog_id) {
if (!td_->dialog_manager_->have_dialog_force(dialog_id, "get_dialog_boost_status")) {
return Status::Error(400, "Chat not found");
}
if (!td_->dialog_manager_->have_input_peer(dialog_id, AccessRights::Read)) {
return Status::Error(400, "Can't access the chat");
}
if (dialog_id.get_type() != DialogType::Channel ||
!td_->contacts_manager_->is_broadcast_channel(dialog_id.get_channel_id())) {
return Status::Error(400, "Can't boost the chat");
}
SliceBuilder sb;
sb << LinkManager::get_t_me_url();
auto username = td_->contacts_manager_->get_channel_first_username(dialog_id.get_channel_id());
bool is_public = !username.empty();
if (is_public) {
sb << username;
} else {
sb << "c/" << dialog_id.get_channel_id().get();
}
sb << "?boost";
return std::make_pair(sb.as_cslice().str(), is_public);
}
void BoostManager::get_dialog_boost_link_info(Slice url, Promise<DialogBoostLinkInfo> &&promise) {
auto r_dialog_boost_link_info = LinkManager::get_dialog_boost_link_info(url);
if (r_dialog_boost_link_info.is_error()) {
return promise.set_error(Status::Error(400, r_dialog_boost_link_info.error().message()));
}
auto info = r_dialog_boost_link_info.move_as_ok();
auto query_promise = PromiseCreator::lambda(
[info, promise = std::move(promise)](Result<DialogId> &&result) mutable { promise.set_value(std::move(info)); });
td_->dialog_manager_->resolve_dialog(info.username, info.channel_id, std::move(query_promise));
}
td_api::object_ptr<td_api::chatBoostLinkInfo> BoostManager::get_chat_boost_link_info_object(
const DialogBoostLinkInfo &info) const {
CHECK(info.username.empty() == info.channel_id.is_valid());
bool is_public = !info.username.empty();
DialogId dialog_id =
is_public ? td_->dialog_manager_->get_resolved_dialog_by_username(info.username) : DialogId(info.channel_id);
return td_api::make_object<td_api::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,
Promise<td_api::object_ptr<td_api::foundChatBoosts>> &&promise) {
if (!td_->dialog_manager_->have_dialog_force(dialog_id, "get_dialog_boosts")) {
return promise.set_error(Status::Error(400, "Chat not found"));
}
if (!td_->dialog_manager_->have_input_peer(dialog_id, AccessRights::Read)) {
return promise.set_error(Status::Error(400, "Can't access the chat"));
}
if (limit <= 0) {
return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
}
td_->create_handler<GetBoostsListQuery>(std::move(promise))->send(dialog_id, only_gift_codes, offset, limit);
}
void BoostManager::get_user_dialog_boosts(DialogId dialog_id, UserId user_id,
Promise<td_api::object_ptr<td_api::foundChatBoosts>> &&promise) {
if (!td_->dialog_manager_->have_dialog_force(dialog_id, "get_user_dialog_boosts")) {
return promise.set_error(Status::Error(400, "Chat not found"));
}
if (!td_->dialog_manager_->have_input_peer(dialog_id, AccessRights::Read)) {
return promise.set_error(Status::Error(400, "Can't access the chat"));
}
if (!user_id.is_valid()) {
return promise.set_error(Status::Error(400, "User not found"));
}
td_->create_handler<GetUserBoostsQuery>(std::move(promise))->send(dialog_id, user_id);
}
void BoostManager::on_update_dialog_boost(DialogId dialog_id, telegram_api::object_ptr<telegram_api::boost> &&boost) {
CHECK(td_->auth_manager_->is_bot());
if (!dialog_id.is_valid() || !td_->dialog_manager_->have_dialog_info_force(dialog_id, "on_update_dialog_boost")) {
LOG(ERROR) << "Receive updateBotChatBoost in " << dialog_id;
return;
}
auto chat_boost_object = get_chat_boost_object(td_, boost);
if (chat_boost_object == nullptr) {
LOG(ERROR) << "Receive wrong updateBotChatBoost in " << dialog_id << ": " << to_string(boost);
return;
}
td_->dialog_manager_->force_create_dialog(dialog_id, "on_update_dialog_boost", true);
send_closure(
G()->td(), &Td::send_update,
td_api::make_object<td_api::updateChatBoost>(
td_->dialog_manager_->get_chat_id_object(dialog_id, "updateChatBoost"), std::move(chat_boost_object)));
}
} // namespace td