2022-01-20 20:54:34 +01:00
|
|
|
//
|
2022-12-31 22:28:08 +01:00
|
|
|
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2023
|
2022-01-20 20:54:34 +01:00
|
|
|
//
|
|
|
|
// 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/MessageReaction.h"
|
|
|
|
|
2022-01-31 13:56:44 +01:00
|
|
|
#include "td/telegram/AccessRights.h"
|
2022-08-15 21:47:02 +02:00
|
|
|
#include "td/telegram/ConfigManager.h"
|
2022-01-20 20:54:34 +01:00
|
|
|
#include "td/telegram/ContactsManager.h"
|
2022-09-24 20:07:35 +02:00
|
|
|
#include "td/telegram/Dependencies.h"
|
2022-01-31 13:56:44 +01:00
|
|
|
#include "td/telegram/Global.h"
|
2022-01-22 21:17:41 +01:00
|
|
|
#include "td/telegram/MessageSender.h"
|
2022-01-21 11:15:27 +01:00
|
|
|
#include "td/telegram/MessagesManager.h"
|
2022-08-18 16:00:18 +02:00
|
|
|
#include "td/telegram/OptionManager.h"
|
2022-01-31 13:56:44 +01:00
|
|
|
#include "td/telegram/ServerMessageId.h"
|
2022-08-15 21:47:02 +02:00
|
|
|
#include "td/telegram/StickersManager.h"
|
2022-01-20 20:54:34 +01:00
|
|
|
#include "td/telegram/Td.h"
|
2023-07-01 13:53:04 +02:00
|
|
|
#include "td/telegram/telegram_api.h"
|
2022-01-21 18:39:55 +01:00
|
|
|
#include "td/telegram/UpdatesManager.h"
|
2022-01-20 20:54:34 +01:00
|
|
|
|
2022-08-15 21:47:02 +02:00
|
|
|
#include "td/actor/actor.h"
|
2023-06-23 13:39:07 +02:00
|
|
|
#include "td/actor/SleepActor.h"
|
2022-08-15 21:47:02 +02:00
|
|
|
|
2022-01-20 20:54:34 +01:00
|
|
|
#include "td/utils/algorithm.h"
|
2022-01-21 14:46:16 +01:00
|
|
|
#include "td/utils/buffer.h"
|
2022-03-11 19:38:48 +01:00
|
|
|
#include "td/utils/FlatHashSet.h"
|
2022-01-20 20:54:34 +01:00
|
|
|
#include "td/utils/logging.h"
|
2022-10-12 14:59:58 +02:00
|
|
|
#include "td/utils/Slice.h"
|
2022-01-31 13:56:44 +01:00
|
|
|
#include "td/utils/Status.h"
|
2022-01-20 20:54:34 +01:00
|
|
|
|
2022-01-31 13:56:44 +01:00
|
|
|
#include <algorithm>
|
|
|
|
#include <utility>
|
2022-01-20 20:54:34 +01:00
|
|
|
|
|
|
|
namespace td {
|
|
|
|
|
2022-09-14 16:55:02 +02:00
|
|
|
static size_t get_max_reaction_count() {
|
|
|
|
bool is_premium = G()->get_option_boolean("is_premium");
|
|
|
|
auto option_key = is_premium ? Slice("reactions_user_max_premium") : Slice("reactions_user_max_default");
|
|
|
|
return static_cast<size_t>(
|
|
|
|
max(static_cast<int32>(1), static_cast<int32>(G()->get_option_integer(option_key, is_premium ? 3 : 1))));
|
|
|
|
}
|
|
|
|
|
2022-01-26 16:48:46 +01:00
|
|
|
class GetMessagesReactionsQuery final : public Td::ResultHandler {
|
|
|
|
DialogId dialog_id_;
|
2022-01-26 18:06:27 +01:00
|
|
|
vector<MessageId> message_ids_;
|
2022-01-26 16:48:46 +01:00
|
|
|
|
|
|
|
public:
|
|
|
|
void send(DialogId dialog_id, vector<MessageId> &&message_ids) {
|
|
|
|
dialog_id_ = dialog_id;
|
2022-01-26 18:06:27 +01:00
|
|
|
message_ids_ = std::move(message_ids);
|
2022-01-26 16:48:46 +01:00
|
|
|
|
|
|
|
auto input_peer = td_->messages_manager_->get_input_peer(dialog_id_, AccessRights::Read);
|
|
|
|
CHECK(input_peer != nullptr);
|
|
|
|
|
2023-06-01 14:53:13 +02:00
|
|
|
send_query(
|
|
|
|
G()->net_query_creator().create(telegram_api::messages_getMessagesReactions(
|
|
|
|
std::move(input_peer), MessageId::get_server_message_ids(message_ids_)),
|
|
|
|
{{dialog_id_}}));
|
2022-01-26 16:48:46 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void on_result(BufferSlice packet) final {
|
|
|
|
auto result_ptr = fetch_result<telegram_api::messages_getMessagesReactions>(packet);
|
|
|
|
if (result_ptr.is_error()) {
|
|
|
|
return on_error(result_ptr.move_as_error());
|
|
|
|
}
|
|
|
|
|
|
|
|
auto ptr = result_ptr.move_as_ok();
|
|
|
|
LOG(INFO) << "Receive result for GetMessagesReactionsQuery: " << to_string(ptr);
|
2022-01-26 18:06:27 +01:00
|
|
|
if (ptr->get_id() == telegram_api::updates::ID) {
|
|
|
|
auto &updates = static_cast<telegram_api::updates *>(ptr.get())->updates_;
|
2022-03-11 19:38:48 +01:00
|
|
|
FlatHashSet<MessageId, MessageIdHash> skipped_message_ids;
|
|
|
|
for (auto message_id : message_ids_) {
|
|
|
|
skipped_message_ids.insert(message_id);
|
|
|
|
}
|
2022-01-26 18:06:27 +01:00
|
|
|
for (const auto &update : updates) {
|
|
|
|
if (update->get_id() == telegram_api::updateMessageReactions::ID) {
|
|
|
|
auto update_message_reactions = static_cast<const telegram_api::updateMessageReactions *>(update.get());
|
|
|
|
if (DialogId(update_message_reactions->peer_) == dialog_id_) {
|
|
|
|
skipped_message_ids.erase(MessageId(ServerMessageId(update_message_reactions->msg_id_)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (auto message_id : skipped_message_ids) {
|
2022-02-12 12:15:14 +01:00
|
|
|
td_->messages_manager_->update_message_reactions({dialog_id_, message_id}, nullptr);
|
2022-01-26 18:06:27 +01:00
|
|
|
}
|
|
|
|
}
|
2022-01-26 16:48:46 +01:00
|
|
|
td_->updates_manager_->on_get_updates(std::move(ptr), Promise<Unit>());
|
2022-03-07 12:27:42 +01:00
|
|
|
td_->messages_manager_->try_reload_message_reactions(dialog_id_, true);
|
2022-01-26 16:48:46 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void on_error(Status status) final {
|
|
|
|
td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "GetMessagesReactionsQuery");
|
2022-03-07 12:27:42 +01:00
|
|
|
td_->messages_manager_->try_reload_message_reactions(dialog_id_, true);
|
2022-01-26 16:48:46 +01:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2022-01-21 18:39:55 +01:00
|
|
|
class SendReactionQuery final : public Td::ResultHandler {
|
|
|
|
Promise<Unit> promise_;
|
|
|
|
DialogId dialog_id_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
explicit SendReactionQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
|
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
void send(FullMessageId full_message_id, vector<ReactionType> reaction_types, bool is_big, bool add_to_recent) {
|
2022-01-21 18:39:55 +01:00
|
|
|
dialog_id_ = full_message_id.get_dialog_id();
|
|
|
|
|
|
|
|
auto input_peer = td_->messages_manager_->get_input_peer(dialog_id_, AccessRights::Read);
|
|
|
|
if (input_peer == nullptr) {
|
|
|
|
return on_error(Status::Error(400, "Can't access the chat"));
|
|
|
|
}
|
|
|
|
|
|
|
|
int32 flags = 0;
|
2023-08-04 17:39:07 +02:00
|
|
|
if (!reaction_types.empty()) {
|
2022-01-21 18:39:55 +01:00
|
|
|
flags |= telegram_api::messages_sendReaction::REACTION_MASK;
|
2022-01-26 14:41:41 +01:00
|
|
|
|
|
|
|
if (is_big) {
|
|
|
|
flags |= telegram_api::messages_sendReaction::BIG_MASK;
|
|
|
|
}
|
2022-09-05 21:04:50 +02:00
|
|
|
|
|
|
|
if (add_to_recent) {
|
|
|
|
flags |= telegram_api::messages_sendReaction::ADD_TO_RECENT_MASK;
|
|
|
|
}
|
2022-01-21 18:39:55 +01:00
|
|
|
}
|
|
|
|
|
2022-02-16 16:36:55 +01:00
|
|
|
send_query(G()->net_query_creator().create(
|
2023-08-04 17:39:07 +02:00
|
|
|
telegram_api::messages_sendReaction(
|
|
|
|
flags, false /*ignored*/, false /*ignored*/, std::move(input_peer),
|
|
|
|
full_message_id.get_message_id().get_server_message_id().get(),
|
|
|
|
transform(reaction_types,
|
|
|
|
[](const ReactionType &reaction_type) { return reaction_type.get_input_reaction(); })),
|
2022-02-16 16:36:55 +01:00
|
|
|
{{dialog_id_}, {full_message_id}}));
|
2022-01-21 18:39:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void on_result(BufferSlice packet) final {
|
|
|
|
auto result_ptr = fetch_result<telegram_api::messages_sendReaction>(packet);
|
|
|
|
if (result_ptr.is_error()) {
|
|
|
|
return on_error(result_ptr.move_as_error());
|
|
|
|
}
|
|
|
|
|
|
|
|
auto ptr = result_ptr.move_as_ok();
|
|
|
|
LOG(INFO) << "Receive result for SendReactionQuery: " << to_string(ptr);
|
|
|
|
td_->updates_manager_->on_get_updates(std::move(ptr), std::move(promise_));
|
|
|
|
}
|
|
|
|
|
|
|
|
void on_error(Status status) final {
|
2022-11-01 12:38:49 +01:00
|
|
|
if (status.message() == "MESSAGE_NOT_MODIFIED") {
|
|
|
|
return promise_.set_value(Unit());
|
|
|
|
}
|
2022-01-21 18:39:55 +01:00
|
|
|
td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "SendReactionQuery");
|
|
|
|
promise_.set_error(std::move(status));
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2022-01-21 14:46:16 +01:00
|
|
|
class GetMessageReactionsListQuery final : public Td::ResultHandler {
|
2022-01-26 23:52:21 +01:00
|
|
|
Promise<td_api::object_ptr<td_api::addedReactions>> promise_;
|
2022-01-21 14:46:16 +01:00
|
|
|
DialogId dialog_id_;
|
|
|
|
MessageId message_id_;
|
2023-08-04 17:39:07 +02:00
|
|
|
ReactionType reaction_type_;
|
2022-01-21 14:46:16 +01:00
|
|
|
string offset_;
|
|
|
|
|
|
|
|
public:
|
2022-01-26 23:52:21 +01:00
|
|
|
explicit GetMessageReactionsListQuery(Promise<td_api::object_ptr<td_api::addedReactions>> &&promise)
|
2022-01-21 14:46:16 +01:00
|
|
|
: promise_(std::move(promise)) {
|
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
void send(FullMessageId full_message_id, ReactionType reaction_type, string offset, int32 limit) {
|
2022-01-21 14:46:16 +01:00
|
|
|
dialog_id_ = full_message_id.get_dialog_id();
|
|
|
|
message_id_ = full_message_id.get_message_id();
|
2023-08-04 17:39:07 +02:00
|
|
|
reaction_type_ = std::move(reaction_type);
|
2022-01-21 14:46:16 +01:00
|
|
|
offset_ = std::move(offset);
|
|
|
|
|
|
|
|
auto input_peer = td_->messages_manager_->get_input_peer(dialog_id_, AccessRights::Read);
|
|
|
|
if (input_peer == nullptr) {
|
|
|
|
return on_error(Status::Error(400, "Can't access the chat"));
|
|
|
|
}
|
|
|
|
|
|
|
|
int32 flags = 0;
|
2023-08-04 17:39:07 +02:00
|
|
|
if (!reaction_type_.is_empty()) {
|
2022-01-21 14:46:16 +01:00
|
|
|
flags |= telegram_api::messages_getMessageReactionsList::REACTION_MASK;
|
|
|
|
}
|
|
|
|
if (!offset_.empty()) {
|
|
|
|
flags |= telegram_api::messages_getMessageReactionsList::OFFSET_MASK;
|
|
|
|
}
|
|
|
|
|
2022-02-16 16:36:55 +01:00
|
|
|
send_query(G()->net_query_creator().create(
|
2022-08-08 22:00:06 +02:00
|
|
|
telegram_api::messages_getMessageReactionsList(flags, std::move(input_peer),
|
|
|
|
message_id_.get_server_message_id().get(),
|
2023-08-04 17:39:07 +02:00
|
|
|
reaction_type_.get_input_reaction(), offset_, limit),
|
2022-02-16 16:36:55 +01:00
|
|
|
{{full_message_id}}));
|
2022-01-21 14:46:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void on_result(BufferSlice packet) final {
|
|
|
|
auto result_ptr = fetch_result<telegram_api::messages_getMessageReactionsList>(packet);
|
|
|
|
if (result_ptr.is_error()) {
|
|
|
|
return on_error(result_ptr.move_as_error());
|
|
|
|
}
|
|
|
|
|
|
|
|
auto ptr = result_ptr.move_as_ok();
|
|
|
|
LOG(INFO) << "Receive result for GetMessageReactionsListQuery: " << to_string(ptr);
|
|
|
|
|
|
|
|
td_->contacts_manager_->on_get_users(std::move(ptr->users_), "GetMessageReactionsListQuery");
|
2022-01-25 10:36:30 +01:00
|
|
|
td_->contacts_manager_->on_get_chats(std::move(ptr->chats_), "GetMessageReactionsListQuery");
|
2022-01-21 14:46:16 +01:00
|
|
|
|
|
|
|
int32 total_count = ptr->count_;
|
2022-02-12 12:15:14 +01:00
|
|
|
auto received_reaction_count = static_cast<int32>(ptr->reactions_.size());
|
|
|
|
if (total_count < received_reaction_count) {
|
2022-01-21 14:46:16 +01:00
|
|
|
LOG(ERROR) << "Receive invalid total_count in " << to_string(ptr);
|
2022-02-12 12:15:14 +01:00
|
|
|
total_count = received_reaction_count;
|
2022-01-21 14:46:16 +01:00
|
|
|
}
|
|
|
|
|
2022-01-26 23:52:21 +01:00
|
|
|
vector<td_api::object_ptr<td_api::addedReaction>> reactions;
|
2023-08-04 17:39:07 +02:00
|
|
|
FlatHashMap<ReactionType, vector<DialogId>, ReactionTypeHash> recent_reaction_types;
|
2022-02-12 12:15:14 +01:00
|
|
|
for (const auto &reaction : ptr->reactions_) {
|
2022-01-25 10:36:30 +01:00
|
|
|
DialogId dialog_id(reaction->peer_id_);
|
2023-08-04 17:39:07 +02:00
|
|
|
auto reaction_type = ReactionType(reaction->reaction_);
|
|
|
|
if (!dialog_id.is_valid() ||
|
|
|
|
(reaction_type_.is_empty() ? reaction_type.is_empty() : reaction_type_ != reaction_type)) {
|
2022-01-21 14:46:16 +01:00
|
|
|
LOG(ERROR) << "Receive unexpected " << to_string(reaction);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2022-02-14 09:34:12 +01:00
|
|
|
if (offset_.empty()) {
|
2023-08-04 17:39:07 +02:00
|
|
|
recent_reaction_types[reaction_type].push_back(dialog_id);
|
2022-02-14 09:34:12 +01:00
|
|
|
}
|
|
|
|
|
2022-01-25 10:36:30 +01:00
|
|
|
auto message_sender = get_min_message_sender_object(td_, dialog_id, "GetMessageReactionsListQuery");
|
2022-01-22 21:17:41 +01:00
|
|
|
if (message_sender != nullptr) {
|
2023-08-04 17:39:07 +02:00
|
|
|
reactions.push_back(td_api::make_object<td_api::addedReaction>(reaction_type.get_reaction_type_object(),
|
2023-03-08 19:12:45 +01:00
|
|
|
std::move(message_sender), reaction->date_));
|
2022-01-22 21:17:41 +01:00
|
|
|
}
|
2022-01-21 14:46:16 +01:00
|
|
|
}
|
|
|
|
|
2022-02-14 09:34:12 +01:00
|
|
|
if (offset_.empty()) {
|
2023-08-04 17:39:07 +02:00
|
|
|
td_->messages_manager_->on_get_message_reaction_list({dialog_id_, message_id_}, reaction_type_,
|
|
|
|
std::move(recent_reaction_types), total_count);
|
2022-02-14 09:34:12 +01:00
|
|
|
}
|
|
|
|
|
2022-01-21 14:46:16 +01:00
|
|
|
promise_.set_value(
|
2022-01-26 23:52:21 +01:00
|
|
|
td_api::make_object<td_api::addedReactions>(total_count, std::move(reactions), ptr->next_offset_));
|
2022-01-21 14:46:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void on_error(Status status) final {
|
|
|
|
td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "GetMessageReactionsListQuery");
|
|
|
|
promise_.set_error(std::move(status));
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2022-08-15 21:47:02 +02:00
|
|
|
class SetDefaultReactionQuery final : public Td::ResultHandler {
|
2023-08-04 17:39:07 +02:00
|
|
|
ReactionType reaction_type_;
|
2022-08-15 21:47:02 +02:00
|
|
|
|
|
|
|
public:
|
2023-08-04 17:39:07 +02:00
|
|
|
void send(const ReactionType &reaction_type) {
|
|
|
|
reaction_type_ = reaction_type;
|
2022-08-08 22:00:06 +02:00
|
|
|
send_query(
|
2023-08-04 17:39:07 +02:00
|
|
|
G()->net_query_creator().create(telegram_api::messages_setDefaultReaction(reaction_type.get_input_reaction())));
|
2022-08-15 21:47:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void on_result(BufferSlice packet) final {
|
|
|
|
auto result_ptr = fetch_result<telegram_api::messages_setDefaultReaction>(packet);
|
|
|
|
if (result_ptr.is_error()) {
|
|
|
|
return on_error(result_ptr.move_as_error());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!result_ptr.ok()) {
|
|
|
|
return on_error(Status::Error(400, "Receive false"));
|
|
|
|
}
|
|
|
|
|
2022-08-18 16:00:18 +02:00
|
|
|
auto default_reaction = td_->option_manager_->get_option_string("default_reaction", "-");
|
2023-08-04 17:39:07 +02:00
|
|
|
if (default_reaction != reaction_type_.get_string()) {
|
2022-08-15 21:47:02 +02:00
|
|
|
send_set_default_reaction_query(td_);
|
|
|
|
} else {
|
2022-08-18 16:00:18 +02:00
|
|
|
td_->option_manager_->set_option_empty("default_reaction_needs_sync");
|
2022-08-15 21:47:02 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void on_error(Status status) final {
|
|
|
|
if (G()->close_flag()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-09-14 15:31:47 +02:00
|
|
|
LOG(INFO) << "Receive error for SetDefaultReactionQuery: " << status;
|
2022-08-18 16:00:18 +02:00
|
|
|
td_->option_manager_->set_option_empty("default_reaction_needs_sync");
|
2022-08-16 22:08:36 +02:00
|
|
|
send_closure(G()->config_manager(), &ConfigManager::request_config, false);
|
2022-08-15 21:47:02 +02:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2022-08-23 13:39:10 +02:00
|
|
|
class ReportReactionQuery final : public Td::ResultHandler {
|
|
|
|
Promise<Unit> promise_;
|
|
|
|
DialogId dialog_id_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
explicit ReportReactionQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
|
|
|
|
}
|
|
|
|
|
|
|
|
void send(DialogId dialog_id, MessageId message_id, DialogId chooser_dialog_id) {
|
|
|
|
dialog_id_ = dialog_id;
|
|
|
|
|
|
|
|
auto input_peer = td_->messages_manager_->get_input_peer(dialog_id_, AccessRights::Read);
|
|
|
|
CHECK(input_peer != nullptr);
|
|
|
|
|
|
|
|
auto chooser_input_peer = td_->messages_manager_->get_input_peer(chooser_dialog_id, AccessRights::Know);
|
|
|
|
if (chooser_input_peer == nullptr) {
|
|
|
|
return promise_.set_error(Status::Error(400, "Reaction sender is not accessible"));
|
|
|
|
}
|
|
|
|
|
|
|
|
send_query(G()->net_query_creator().create(telegram_api::messages_reportReaction(
|
|
|
|
std::move(input_peer), message_id.get_server_message_id().get(), std::move(chooser_input_peer))));
|
|
|
|
}
|
|
|
|
|
|
|
|
void on_result(BufferSlice packet) final {
|
|
|
|
auto result_ptr = fetch_result<telegram_api::messages_reportReaction>(packet);
|
|
|
|
if (result_ptr.is_error()) {
|
|
|
|
return on_error(result_ptr.move_as_error());
|
|
|
|
}
|
|
|
|
|
|
|
|
promise_.set_value(Unit());
|
|
|
|
}
|
|
|
|
|
|
|
|
void on_error(Status status) final {
|
|
|
|
td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "ReportReactionQuery");
|
|
|
|
promise_.set_error(std::move(status));
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
MessageReaction::MessageReaction(ReactionType reaction_type, int32 choose_count, bool is_chosen,
|
2023-07-13 12:54:58 +02:00
|
|
|
DialogId my_recent_chooser_dialog_id, vector<DialogId> &&recent_chooser_dialog_ids,
|
|
|
|
vector<std::pair<ChannelId, MinChannel>> &&recent_chooser_min_channels)
|
2023-08-04 17:39:07 +02:00
|
|
|
: reaction_type_(std::move(reaction_type))
|
2023-07-13 12:54:58 +02:00
|
|
|
, choose_count_(choose_count)
|
|
|
|
, is_chosen_(is_chosen)
|
|
|
|
, my_recent_chooser_dialog_id_(my_recent_chooser_dialog_id)
|
|
|
|
, recent_chooser_dialog_ids_(std::move(recent_chooser_dialog_ids))
|
|
|
|
, recent_chooser_min_channels_(std::move(recent_chooser_min_channels)) {
|
|
|
|
if (my_recent_chooser_dialog_id_.is_valid()) {
|
|
|
|
CHECK(td::contains(recent_chooser_dialog_ids_, my_recent_chooser_dialog_id_));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-27 21:13:05 +02:00
|
|
|
void MessageReaction::add_recent_chooser_dialog_id(DialogId dialog_id) {
|
2023-04-27 15:20:54 +02:00
|
|
|
CHECK(!my_recent_chooser_dialog_id_.is_valid());
|
|
|
|
my_recent_chooser_dialog_id_ = dialog_id;
|
2022-04-27 21:13:05 +02:00
|
|
|
recent_chooser_dialog_ids_.insert(recent_chooser_dialog_ids_.begin(), dialog_id);
|
2022-08-07 14:28:55 +02:00
|
|
|
if (recent_chooser_dialog_ids_.size() > MAX_RECENT_CHOOSERS + 1) {
|
|
|
|
LOG(ERROR) << "Have " << recent_chooser_dialog_ids_.size() << " recent reaction choosers";
|
|
|
|
recent_chooser_dialog_ids_.resize(MAX_RECENT_CHOOSERS + 1);
|
2022-04-27 21:13:05 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-04-27 15:20:54 +02:00
|
|
|
bool MessageReaction::remove_recent_chooser_dialog_id() {
|
|
|
|
if (my_recent_chooser_dialog_id_.is_valid()) {
|
|
|
|
bool is_removed = td::remove(recent_chooser_dialog_ids_, my_recent_chooser_dialog_id_);
|
|
|
|
CHECK(is_removed);
|
|
|
|
my_recent_chooser_dialog_id_ = DialogId();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
2022-04-27 21:13:05 +02:00
|
|
|
}
|
|
|
|
|
2023-04-27 15:37:15 +02:00
|
|
|
void MessageReaction::update_from(const MessageReaction &old_reaction) {
|
|
|
|
CHECK(old_reaction.is_chosen());
|
|
|
|
is_chosen_ = true;
|
|
|
|
|
|
|
|
auto my_dialog_id = old_reaction.get_my_recent_chooser_dialog_id();
|
|
|
|
if (my_dialog_id.is_valid() && td::contains(recent_chooser_dialog_ids_, my_dialog_id)) {
|
|
|
|
my_recent_chooser_dialog_id_ = my_dialog_id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-07 14:28:55 +02:00
|
|
|
void MessageReaction::update_recent_chooser_dialog_ids(const MessageReaction &old_reaction) {
|
|
|
|
if (recent_chooser_dialog_ids_.size() != MAX_RECENT_CHOOSERS) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
CHECK(is_chosen_ && old_reaction.is_chosen_);
|
2023-08-04 17:39:07 +02:00
|
|
|
CHECK(reaction_type_ == old_reaction.reaction_type_);
|
2022-08-07 14:28:55 +02:00
|
|
|
CHECK(old_reaction.recent_chooser_dialog_ids_.size() == MAX_RECENT_CHOOSERS + 1);
|
|
|
|
for (size_t i = 0; i < MAX_RECENT_CHOOSERS; i++) {
|
|
|
|
if (recent_chooser_dialog_ids_[i] != old_reaction.recent_chooser_dialog_ids_[i]) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2023-04-27 15:20:54 +02:00
|
|
|
my_recent_chooser_dialog_id_ = old_reaction.my_recent_chooser_dialog_id_;
|
2022-08-07 14:28:55 +02:00
|
|
|
recent_chooser_dialog_ids_ = old_reaction.recent_chooser_dialog_ids_;
|
|
|
|
recent_chooser_min_channels_ = old_reaction.recent_chooser_min_channels_;
|
|
|
|
}
|
|
|
|
|
2023-04-27 18:31:31 +02:00
|
|
|
void MessageReaction::set_as_chosen(DialogId my_dialog_id, bool have_recent_choosers) {
|
2023-04-27 15:42:38 +02:00
|
|
|
CHECK(!is_chosen_);
|
|
|
|
|
|
|
|
is_chosen_ = true;
|
|
|
|
choose_count_++;
|
|
|
|
if (have_recent_choosers) {
|
|
|
|
remove_recent_chooser_dialog_id();
|
2023-04-27 18:31:31 +02:00
|
|
|
add_recent_chooser_dialog_id(my_dialog_id);
|
2022-01-21 18:39:55 +01:00
|
|
|
}
|
2023-04-27 15:42:38 +02:00
|
|
|
}
|
2022-01-21 18:39:55 +01:00
|
|
|
|
2023-04-27 15:42:38 +02:00
|
|
|
void MessageReaction::unset_as_chosen() {
|
|
|
|
CHECK(is_chosen_);
|
2022-01-21 18:39:55 +01:00
|
|
|
|
2023-04-27 15:42:38 +02:00
|
|
|
is_chosen_ = false;
|
|
|
|
choose_count_--;
|
|
|
|
remove_recent_chooser_dialog_id();
|
2022-01-21 18:39:55 +01:00
|
|
|
}
|
|
|
|
|
2023-04-27 18:31:31 +02:00
|
|
|
void MessageReaction::set_my_recent_chooser_dialog_id(DialogId my_dialog_id) {
|
|
|
|
if (!my_recent_chooser_dialog_id_.is_valid() || my_recent_chooser_dialog_id_ == my_dialog_id) {
|
|
|
|
return;
|
|
|
|
}
|
2023-05-01 17:09:27 +02:00
|
|
|
td::remove(recent_chooser_dialog_ids_, my_dialog_id);
|
|
|
|
for (auto &dialog_id : recent_chooser_dialog_ids_) {
|
|
|
|
if (dialog_id == my_recent_chooser_dialog_id_) {
|
|
|
|
dialog_id = my_dialog_id;
|
|
|
|
}
|
2023-04-27 18:31:31 +02:00
|
|
|
}
|
2023-05-01 17:09:27 +02:00
|
|
|
CHECK(td::contains(recent_chooser_dialog_ids_, my_dialog_id));
|
|
|
|
my_recent_chooser_dialog_id_ = my_dialog_id;
|
2023-04-27 18:31:31 +02:00
|
|
|
}
|
|
|
|
|
2022-09-14 16:15:12 +02:00
|
|
|
td_api::object_ptr<td_api::messageReaction> MessageReaction::get_message_reaction_object(Td *td, UserId my_user_id,
|
|
|
|
UserId peer_user_id) const {
|
2022-01-20 20:54:34 +01:00
|
|
|
CHECK(!is_empty());
|
|
|
|
|
2022-01-21 11:15:27 +01:00
|
|
|
vector<td_api::object_ptr<td_api::MessageSender>> recent_choosers;
|
2022-09-14 16:15:12 +02:00
|
|
|
if (my_user_id.is_valid()) {
|
|
|
|
CHECK(peer_user_id.is_valid());
|
|
|
|
if (is_chosen()) {
|
|
|
|
auto recent_chooser = get_min_message_sender_object(td, DialogId(my_user_id), "get_message_reaction_object");
|
|
|
|
if (recent_chooser != nullptr) {
|
|
|
|
recent_choosers.push_back(std::move(recent_chooser));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (choose_count_ >= (is_chosen() ? 2 : 1)) {
|
|
|
|
auto recent_chooser = get_min_message_sender_object(td, DialogId(peer_user_id), "get_message_reaction_object");
|
|
|
|
if (recent_chooser != nullptr) {
|
|
|
|
recent_choosers.push_back(std::move(recent_chooser));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (auto dialog_id : recent_chooser_dialog_ids_) {
|
|
|
|
auto recent_chooser = get_min_message_sender_object(td, dialog_id, "get_message_reaction_object");
|
|
|
|
if (recent_chooser != nullptr) {
|
|
|
|
recent_choosers.push_back(std::move(recent_chooser));
|
|
|
|
if (recent_choosers.size() == MAX_RECENT_CHOOSERS) {
|
|
|
|
break;
|
|
|
|
}
|
2022-08-07 14:28:55 +02:00
|
|
|
}
|
2022-01-20 20:54:34 +01:00
|
|
|
}
|
|
|
|
}
|
2023-08-04 17:39:07 +02:00
|
|
|
return td_api::make_object<td_api::messageReaction>(reaction_type_.get_reaction_type_object(), choose_count_,
|
|
|
|
is_chosen_, std::move(recent_choosers));
|
2022-01-20 20:54:34 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
bool operator==(const MessageReaction &lhs, const MessageReaction &rhs) {
|
2023-08-04 17:39:07 +02:00
|
|
|
return lhs.reaction_type_ == rhs.reaction_type_ && lhs.choose_count_ == rhs.choose_count_ &&
|
|
|
|
lhs.is_chosen_ == rhs.is_chosen_ && lhs.my_recent_chooser_dialog_id_ == rhs.my_recent_chooser_dialog_id_ &&
|
2022-01-21 11:15:27 +01:00
|
|
|
lhs.recent_chooser_dialog_ids_ == rhs.recent_chooser_dialog_ids_;
|
2022-01-20 20:54:34 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
StringBuilder &operator<<(StringBuilder &string_builder, const MessageReaction &reaction) {
|
2023-08-04 17:39:07 +02:00
|
|
|
string_builder << '[' << reaction.reaction_type_ << (reaction.is_chosen_ ? " X " : " x ") << reaction.choose_count_;
|
2022-01-21 11:15:27 +01:00
|
|
|
if (!reaction.recent_chooser_dialog_ids_.empty()) {
|
|
|
|
string_builder << " by " << reaction.recent_chooser_dialog_ids_;
|
2023-05-01 17:09:27 +02:00
|
|
|
if (reaction.my_recent_chooser_dialog_id_.is_valid()) {
|
|
|
|
string_builder << " and my " << reaction.my_recent_chooser_dialog_id_;
|
|
|
|
}
|
2022-01-20 20:54:34 +01:00
|
|
|
}
|
|
|
|
return string_builder << ']';
|
|
|
|
}
|
|
|
|
|
2022-01-28 15:10:17 +01:00
|
|
|
td_api::object_ptr<td_api::unreadReaction> UnreadMessageReaction::get_unread_reaction_object(Td *td) const {
|
|
|
|
auto sender_id = get_min_message_sender_object(td, sender_dialog_id_, "get_unread_reaction_object");
|
|
|
|
if (sender_id == nullptr) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
2023-08-04 17:39:07 +02:00
|
|
|
return td_api::make_object<td_api::unreadReaction>(reaction_type_.get_reaction_type_object(), std::move(sender_id),
|
2022-08-16 21:42:29 +02:00
|
|
|
is_big_);
|
2022-01-28 15:10:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
bool operator==(const UnreadMessageReaction &lhs, const UnreadMessageReaction &rhs) {
|
2023-08-04 17:39:07 +02:00
|
|
|
return lhs.reaction_type_ == rhs.reaction_type_ && lhs.sender_dialog_id_ == rhs.sender_dialog_id_ &&
|
|
|
|
lhs.is_big_ == rhs.is_big_;
|
2022-01-28 15:10:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
StringBuilder &operator<<(StringBuilder &string_builder, const UnreadMessageReaction &unread_reaction) {
|
2023-08-04 17:39:07 +02:00
|
|
|
return string_builder << '[' << unread_reaction.reaction_type_ << (unread_reaction.is_big_ ? " BY " : " by ")
|
2022-01-28 15:10:17 +01:00
|
|
|
<< unread_reaction.sender_dialog_id_ << ']';
|
|
|
|
}
|
|
|
|
|
2022-01-20 20:54:34 +01:00
|
|
|
unique_ptr<MessageReactions> MessageReactions::get_message_reactions(
|
|
|
|
Td *td, tl_object_ptr<telegram_api::messageReactions> &&reactions, bool is_bot) {
|
|
|
|
if (reactions == nullptr || is_bot) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto result = make_unique<MessageReactions>();
|
2022-01-30 11:24:27 +01:00
|
|
|
result->can_get_added_reactions_ = reactions->can_see_list_;
|
2022-01-20 20:54:34 +01:00
|
|
|
result->is_min_ = reactions->min_;
|
|
|
|
|
2023-04-27 17:46:51 +02:00
|
|
|
DialogId my_dialog_id;
|
|
|
|
for (auto &peer_reaction : reactions->recent_reactions_) {
|
|
|
|
if (peer_reaction->my_) {
|
|
|
|
DialogId dialog_id(peer_reaction->peer_id_);
|
|
|
|
if (!dialog_id.is_valid()) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (my_dialog_id.is_valid() && dialog_id != my_dialog_id) {
|
|
|
|
LOG(ERROR) << "Receive my reactions with " << dialog_id << " and " << my_dialog_id;
|
|
|
|
}
|
|
|
|
my_dialog_id = dialog_id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
FlatHashSet<ReactionType, ReactionTypeHash> reaction_types;
|
|
|
|
vector<std::pair<int32, ReactionType>> chosen_reaction_order;
|
2022-01-20 20:54:34 +01:00
|
|
|
for (auto &reaction_count : reactions->results_) {
|
2023-08-04 17:39:07 +02:00
|
|
|
auto reaction_type = ReactionType(reaction_count->reaction_);
|
2022-03-11 19:38:48 +01:00
|
|
|
if (reaction_count->count_ <= 0 || reaction_count->count_ >= MessageReaction::MAX_CHOOSE_COUNT ||
|
2023-08-04 17:39:07 +02:00
|
|
|
reaction_type.is_empty()) {
|
2023-08-04 17:44:54 +02:00
|
|
|
LOG(ERROR) << "Receive " << reaction_type << " with invalid count " << reaction_count->count_;
|
2022-01-20 20:54:34 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
if (!reaction_types.insert(reaction_type).second) {
|
2023-08-04 17:44:54 +02:00
|
|
|
LOG(ERROR) << "Receive duplicate " << reaction_type;
|
2022-01-20 20:54:34 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2022-09-02 16:04:09 +02:00
|
|
|
FlatHashSet<DialogId, DialogIdHash> recent_choosers;
|
2023-07-13 12:54:58 +02:00
|
|
|
DialogId my_recent_chooser_dialog_id;
|
2022-01-21 11:15:27 +01:00
|
|
|
vector<DialogId> recent_chooser_dialog_ids;
|
|
|
|
vector<std::pair<ChannelId, MinChannel>> recent_chooser_min_channels;
|
2022-01-25 10:36:30 +01:00
|
|
|
for (auto &peer_reaction : reactions->recent_reactions_) {
|
2023-08-04 17:39:07 +02:00
|
|
|
auto peer_reaction_type = ReactionType(peer_reaction->reaction_);
|
|
|
|
if (peer_reaction_type == reaction_type) {
|
2022-01-25 10:36:30 +01:00
|
|
|
DialogId dialog_id(peer_reaction->peer_id_);
|
2022-01-21 11:15:27 +01:00
|
|
|
if (!dialog_id.is_valid()) {
|
2023-08-04 17:44:54 +02:00
|
|
|
LOG(ERROR) << "Receive invalid " << dialog_id << " as a recent chooser for " << reaction_type;
|
2022-01-20 20:54:34 +01:00
|
|
|
continue;
|
|
|
|
}
|
2022-01-21 11:15:27 +01:00
|
|
|
if (!recent_choosers.insert(dialog_id).second) {
|
2023-08-04 17:44:54 +02:00
|
|
|
LOG(ERROR) << "Receive duplicate " << dialog_id << " as a recent chooser for " << reaction_type;
|
2022-01-20 20:54:34 +01:00
|
|
|
continue;
|
|
|
|
}
|
2022-01-21 11:15:27 +01:00
|
|
|
if (!td->messages_manager_->have_dialog_info(dialog_id)) {
|
|
|
|
auto dialog_type = dialog_id.get_type();
|
|
|
|
if (dialog_type == DialogType::User) {
|
|
|
|
auto user_id = dialog_id.get_user_id();
|
|
|
|
if (!td->contacts_manager_->have_min_user(user_id)) {
|
2022-10-05 20:29:05 +02:00
|
|
|
LOG(ERROR) << "Receive unknown " << user_id;
|
2022-01-21 11:15:27 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} else if (dialog_type == DialogType::Channel) {
|
|
|
|
auto channel_id = dialog_id.get_channel_id();
|
|
|
|
auto min_channel = td->contacts_manager_->get_min_channel(channel_id);
|
|
|
|
if (min_channel == nullptr) {
|
2022-10-05 20:29:05 +02:00
|
|
|
LOG(ERROR) << "Receive unknown reacted " << channel_id;
|
2022-01-21 11:15:27 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
recent_chooser_min_channels.emplace_back(channel_id, *min_channel);
|
|
|
|
} else {
|
2022-10-05 20:29:05 +02:00
|
|
|
LOG(ERROR) << "Receive unknown reacted " << dialog_id;
|
2022-01-21 11:15:27 +01:00
|
|
|
continue;
|
|
|
|
}
|
2022-01-20 20:54:34 +01:00
|
|
|
}
|
|
|
|
|
2022-01-21 11:15:27 +01:00
|
|
|
recent_chooser_dialog_ids.push_back(dialog_id);
|
2023-07-13 12:54:58 +02:00
|
|
|
if (dialog_id == my_dialog_id) {
|
|
|
|
my_recent_chooser_dialog_id = dialog_id;
|
|
|
|
}
|
2022-01-28 15:10:17 +01:00
|
|
|
if (peer_reaction->unread_) {
|
2023-08-04 17:39:07 +02:00
|
|
|
result->unread_reactions_.emplace_back(std::move(peer_reaction_type), dialog_id, peer_reaction->big_);
|
2022-01-28 15:10:17 +01:00
|
|
|
}
|
2022-01-21 11:15:27 +01:00
|
|
|
if (recent_chooser_dialog_ids.size() == MessageReaction::MAX_RECENT_CHOOSERS) {
|
2022-01-20 20:54:34 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-09-02 16:34:28 +02:00
|
|
|
bool is_chosen = (reaction_count->flags_ & telegram_api::reactionCount::CHOSEN_ORDER_MASK) != 0;
|
2022-09-11 12:35:25 +02:00
|
|
|
if (is_chosen) {
|
2023-08-04 17:39:07 +02:00
|
|
|
chosen_reaction_order.emplace_back(reaction_count->chosen_order_, reaction_type);
|
2022-09-11 12:35:25 +02:00
|
|
|
}
|
2023-08-04 17:39:07 +02:00
|
|
|
result->reactions_.push_back({std::move(reaction_type), reaction_count->count_, is_chosen,
|
2023-07-13 12:54:58 +02:00
|
|
|
my_recent_chooser_dialog_id, std::move(recent_chooser_dialog_ids),
|
|
|
|
std::move(recent_chooser_min_channels)});
|
2022-01-20 20:54:34 +01:00
|
|
|
}
|
2022-09-11 12:35:25 +02:00
|
|
|
if (chosen_reaction_order.size() > 1) {
|
|
|
|
std::sort(chosen_reaction_order.begin(), chosen_reaction_order.end());
|
|
|
|
result->chosen_reaction_order_ =
|
2023-08-04 17:39:07 +02:00
|
|
|
transform(chosen_reaction_order, [](const std::pair<int32, ReactionType> &order) { return order.second; });
|
2022-09-11 12:35:25 +02:00
|
|
|
}
|
2022-01-20 20:54:34 +01:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
MessageReaction *MessageReactions::get_reaction(const ReactionType &reaction_type) {
|
2022-01-26 23:52:21 +01:00
|
|
|
for (auto &added_reaction : reactions_) {
|
2023-08-04 17:39:07 +02:00
|
|
|
if (added_reaction.get_reaction_type() == reaction_type) {
|
2022-01-26 23:52:21 +01:00
|
|
|
return &added_reaction;
|
2022-01-26 13:25:03 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
const MessageReaction *MessageReactions::get_reaction(const ReactionType &reaction_type) const {
|
2022-01-26 23:52:21 +01:00
|
|
|
for (auto &added_reaction : reactions_) {
|
2023-08-04 17:39:07 +02:00
|
|
|
if (added_reaction.get_reaction_type() == reaction_type) {
|
2022-01-26 23:52:21 +01:00
|
|
|
return &added_reaction;
|
2022-01-26 14:51:47 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2022-01-20 20:54:34 +01:00
|
|
|
void MessageReactions::update_from(const MessageReactions &old_reactions) {
|
|
|
|
if (is_min_ && !old_reactions.is_min_) {
|
2023-04-27 16:26:26 +02:00
|
|
|
// chosen reactions were known, keep them
|
2022-01-20 20:54:34 +01:00
|
|
|
is_min_ = false;
|
2023-04-27 16:26:26 +02:00
|
|
|
chosen_reaction_order_ = old_reactions.chosen_reaction_order_;
|
2022-01-20 20:54:34 +01:00
|
|
|
for (const auto &old_reaction : old_reactions.reactions_) {
|
|
|
|
if (old_reaction.is_chosen()) {
|
2023-08-04 17:39:07 +02:00
|
|
|
auto *reaction = get_reaction(old_reaction.get_reaction_type());
|
2022-01-26 13:25:03 +01:00
|
|
|
if (reaction != nullptr) {
|
2023-04-27 15:37:15 +02:00
|
|
|
reaction->update_from(old_reaction);
|
2022-01-20 20:54:34 +01:00
|
|
|
}
|
2023-04-27 16:26:26 +02:00
|
|
|
} else {
|
2023-08-04 17:39:07 +02:00
|
|
|
td::remove(chosen_reaction_order_, old_reaction.get_reaction_type());
|
2022-01-20 20:54:34 +01:00
|
|
|
}
|
|
|
|
}
|
2022-02-12 12:15:14 +01:00
|
|
|
unread_reactions_ = old_reactions.unread_reactions_;
|
2023-04-27 16:26:26 +02:00
|
|
|
if (chosen_reaction_order_.size() == 1) {
|
|
|
|
reset_to_empty(chosen_reaction_order_);
|
|
|
|
}
|
2022-01-20 20:54:34 +01:00
|
|
|
}
|
2022-08-07 14:28:55 +02:00
|
|
|
for (const auto &old_reaction : old_reactions.reactions_) {
|
|
|
|
if (old_reaction.is_chosen() &&
|
|
|
|
old_reaction.get_recent_chooser_dialog_ids().size() == MessageReaction::MAX_RECENT_CHOOSERS + 1) {
|
2023-08-04 17:39:07 +02:00
|
|
|
auto *reaction = get_reaction(old_reaction.get_reaction_type());
|
2022-08-07 14:28:55 +02:00
|
|
|
if (reaction != nullptr && reaction->is_chosen()) {
|
|
|
|
reaction->update_recent_chooser_dialog_ids(old_reaction);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-01-20 20:54:34 +01:00
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
bool MessageReactions::add_reaction(const ReactionType &reaction_type, bool is_big, DialogId my_dialog_id,
|
2022-09-09 16:43:21 +02:00
|
|
|
bool have_recent_choosers) {
|
2023-08-04 17:39:07 +02:00
|
|
|
vector<ReactionType> new_chosen_reaction_order = get_chosen_reaction_types();
|
2022-09-09 16:43:21 +02:00
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
auto added_reaction = get_reaction(reaction_type);
|
2022-09-11 14:10:56 +02:00
|
|
|
if (added_reaction == nullptr) {
|
|
|
|
vector<DialogId> recent_chooser_dialog_ids;
|
2023-07-13 12:54:58 +02:00
|
|
|
DialogId my_recent_chooser_dialog_id;
|
2022-09-11 14:10:56 +02:00
|
|
|
if (have_recent_choosers) {
|
2023-04-27 18:31:31 +02:00
|
|
|
recent_chooser_dialog_ids.push_back(my_dialog_id);
|
2023-07-13 12:54:58 +02:00
|
|
|
my_recent_chooser_dialog_id = my_dialog_id;
|
2022-09-09 16:43:21 +02:00
|
|
|
}
|
2023-07-13 12:54:58 +02:00
|
|
|
reactions_.push_back(
|
2023-08-04 17:39:07 +02:00
|
|
|
{reaction_type, 1, true, my_recent_chooser_dialog_id, std::move(recent_chooser_dialog_ids), Auto()});
|
|
|
|
new_chosen_reaction_order.emplace_back(reaction_type);
|
2022-09-11 14:10:56 +02:00
|
|
|
} else if (!added_reaction->is_chosen()) {
|
2023-04-27 18:31:31 +02:00
|
|
|
added_reaction->set_as_chosen(my_dialog_id, have_recent_choosers);
|
2023-08-04 17:39:07 +02:00
|
|
|
new_chosen_reaction_order.emplace_back(reaction_type);
|
2022-09-11 14:10:56 +02:00
|
|
|
} else if (!is_big) {
|
|
|
|
return false;
|
2022-09-09 16:43:21 +02:00
|
|
|
}
|
|
|
|
|
2022-09-14 16:55:02 +02:00
|
|
|
auto max_reaction_count = get_max_reaction_count();
|
|
|
|
while (new_chosen_reaction_order.size() > max_reaction_count) {
|
2023-08-04 17:39:07 +02:00
|
|
|
auto index = new_chosen_reaction_order[0] == reaction_type ? 1 : 0;
|
2022-09-14 16:55:02 +02:00
|
|
|
CHECK(static_cast<size_t>(index) < new_chosen_reaction_order.size());
|
2023-04-27 15:42:38 +02:00
|
|
|
bool is_removed = do_remove_reaction(new_chosen_reaction_order[index]);
|
2022-09-11 14:10:56 +02:00
|
|
|
CHECK(is_removed);
|
2022-09-14 16:55:02 +02:00
|
|
|
new_chosen_reaction_order.erase(new_chosen_reaction_order.begin() + index);
|
2022-09-09 16:43:21 +02:00
|
|
|
}
|
|
|
|
|
2022-09-11 14:10:56 +02:00
|
|
|
if (new_chosen_reaction_order.size() == 1) {
|
|
|
|
new_chosen_reaction_order.clear();
|
2022-09-09 16:43:21 +02:00
|
|
|
}
|
2022-09-11 14:10:56 +02:00
|
|
|
chosen_reaction_order_ = std::move(new_chosen_reaction_order);
|
2023-04-27 18:31:31 +02:00
|
|
|
|
|
|
|
for (auto &message_reaction : reactions_) {
|
|
|
|
message_reaction.set_my_recent_chooser_dialog_id(my_dialog_id);
|
|
|
|
}
|
|
|
|
|
2022-09-09 16:43:21 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
bool MessageReactions::remove_reaction(const ReactionType &reaction_type, DialogId my_dialog_id) {
|
|
|
|
if (do_remove_reaction(reaction_type)) {
|
2022-09-11 14:10:56 +02:00
|
|
|
if (!chosen_reaction_order_.empty()) {
|
2023-08-04 17:39:07 +02:00
|
|
|
bool is_removed = td::remove(chosen_reaction_order_, reaction_type);
|
2022-09-11 14:10:56 +02:00
|
|
|
CHECK(is_removed);
|
2022-09-14 16:55:02 +02:00
|
|
|
|
2023-04-27 15:42:38 +02:00
|
|
|
// if the user isn't a Premium user, then max_reaction_count could be reduced from 3 to 1
|
2022-09-14 16:55:02 +02:00
|
|
|
auto max_reaction_count = get_max_reaction_count();
|
|
|
|
while (chosen_reaction_order_.size() > max_reaction_count) {
|
2023-04-27 15:42:38 +02:00
|
|
|
is_removed = do_remove_reaction(chosen_reaction_order_[0]);
|
2022-09-14 16:55:02 +02:00
|
|
|
CHECK(is_removed);
|
|
|
|
chosen_reaction_order_.erase(chosen_reaction_order_.begin());
|
|
|
|
}
|
|
|
|
|
2022-09-11 14:10:56 +02:00
|
|
|
if (chosen_reaction_order_.size() <= 1) {
|
|
|
|
reset_to_empty(chosen_reaction_order_);
|
|
|
|
}
|
|
|
|
}
|
2022-09-14 16:55:02 +02:00
|
|
|
|
2023-05-01 17:28:06 +02:00
|
|
|
for (auto &message_reaction : reactions_) {
|
|
|
|
message_reaction.set_my_recent_chooser_dialog_id(my_dialog_id);
|
|
|
|
}
|
|
|
|
|
2022-09-11 14:10:56 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
bool MessageReactions::do_remove_reaction(const ReactionType &reaction_type) {
|
2022-09-09 16:43:21 +02:00
|
|
|
for (auto it = reactions_.begin(); it != reactions_.end(); ++it) {
|
|
|
|
auto &message_reaction = *it;
|
2023-08-04 17:39:07 +02:00
|
|
|
if (message_reaction.get_reaction_type() == reaction_type) {
|
2022-09-09 16:43:21 +02:00
|
|
|
if (message_reaction.is_chosen()) {
|
2023-04-27 15:42:38 +02:00
|
|
|
message_reaction.unset_as_chosen();
|
2022-09-09 16:43:21 +02:00
|
|
|
if (message_reaction.is_empty()) {
|
|
|
|
it = reactions_.erase(it);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
void MessageReactions::sort_reactions(const FlatHashMap<ReactionType, size_t, ReactionTypeHash> &active_reaction_pos) {
|
2022-01-26 10:50:41 +01:00
|
|
|
std::sort(reactions_.begin(), reactions_.end(),
|
|
|
|
[&active_reaction_pos](const MessageReaction &lhs, const MessageReaction &rhs) {
|
|
|
|
if (lhs.get_choose_count() != rhs.get_choose_count()) {
|
|
|
|
return lhs.get_choose_count() > rhs.get_choose_count();
|
|
|
|
}
|
2023-08-04 17:39:07 +02:00
|
|
|
auto lhs_it = active_reaction_pos.find(lhs.get_reaction_type());
|
2022-01-26 10:50:41 +01:00
|
|
|
auto lhs_pos = lhs_it != active_reaction_pos.end() ? lhs_it->second : active_reaction_pos.size();
|
2023-08-04 17:39:07 +02:00
|
|
|
auto rhs_it = active_reaction_pos.find(rhs.get_reaction_type());
|
2022-01-26 10:50:41 +01:00
|
|
|
auto rhs_pos = rhs_it != active_reaction_pos.end() ? rhs_it->second : active_reaction_pos.size();
|
|
|
|
if (lhs_pos != rhs_pos) {
|
|
|
|
return lhs_pos < rhs_pos;
|
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
return lhs.get_reaction_type() < rhs.get_reaction_type();
|
2022-01-26 10:50:41 +01:00
|
|
|
});
|
2022-01-26 10:01:14 +01:00
|
|
|
}
|
|
|
|
|
2023-04-27 15:20:54 +02:00
|
|
|
void MessageReactions::fix_chosen_reaction() {
|
|
|
|
DialogId my_dialog_id;
|
2022-04-27 21:13:05 +02:00
|
|
|
for (auto &reaction : reactions_) {
|
2023-04-27 15:20:54 +02:00
|
|
|
if (!reaction.is_chosen() && reaction.get_my_recent_chooser_dialog_id().is_valid()) {
|
|
|
|
my_dialog_id = reaction.get_my_recent_chooser_dialog_id();
|
2022-04-27 21:13:05 +02:00
|
|
|
LOG(WARNING) << "Fix recent chosen reaction in " << *this;
|
2023-04-27 15:20:54 +02:00
|
|
|
reaction.remove_recent_chooser_dialog_id();
|
2022-04-27 21:13:05 +02:00
|
|
|
}
|
|
|
|
}
|
2023-04-27 15:20:54 +02:00
|
|
|
if (!my_dialog_id.is_valid()) {
|
2022-04-27 21:13:05 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (auto &reaction : reactions_) {
|
2023-04-27 15:20:54 +02:00
|
|
|
if (reaction.is_chosen() && !reaction.get_my_recent_chooser_dialog_id().is_valid()) {
|
2022-04-27 21:13:05 +02:00
|
|
|
reaction.add_recent_chooser_dialog_id(my_dialog_id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-04-27 15:20:54 +02:00
|
|
|
void MessageReactions::fix_my_recent_chooser_dialog_id(DialogId my_dialog_id) {
|
|
|
|
for (auto &reaction : reactions_) {
|
|
|
|
if (reaction.is_chosen() && !reaction.get_my_recent_chooser_dialog_id().is_valid() &&
|
|
|
|
td::contains(reaction.get_recent_chooser_dialog_ids(), my_dialog_id)) {
|
|
|
|
reaction.my_recent_chooser_dialog_id_ = my_dialog_id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
vector<ReactionType> MessageReactions::get_chosen_reaction_types() const {
|
2022-09-11 13:06:01 +02:00
|
|
|
if (!chosen_reaction_order_.empty()) {
|
|
|
|
return chosen_reaction_order_;
|
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
vector<ReactionType> reaction_order;
|
2022-09-11 13:06:01 +02:00
|
|
|
for (auto &reaction : reactions_) {
|
|
|
|
if (reaction.is_chosen()) {
|
2023-08-04 17:39:07 +02:00
|
|
|
reaction_order.push_back(reaction.get_reaction_type());
|
2022-09-11 13:06:01 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return reaction_order;
|
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
bool MessageReactions::are_consistent_with_list(
|
|
|
|
const ReactionType &reaction_type, FlatHashMap<ReactionType, vector<DialogId>, ReactionTypeHash> reaction_types,
|
|
|
|
int32 total_count) const {
|
2022-09-24 19:15:38 +02:00
|
|
|
auto are_consistent = [](const vector<DialogId> &lhs, const vector<DialogId> &rhs) {
|
|
|
|
size_t i = 0;
|
|
|
|
size_t max_i = td::min(lhs.size(), rhs.size());
|
|
|
|
while (i < max_i && lhs[i] == rhs[i]) {
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
return i == max_i;
|
|
|
|
};
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
if (reaction_type.is_empty()) {
|
2022-09-24 19:15:38 +02:00
|
|
|
// received list and total_count for all reactions
|
|
|
|
int32 old_total_count = 0;
|
|
|
|
for (const auto &message_reaction : reactions_) {
|
2023-08-04 17:39:07 +02:00
|
|
|
CHECK(!message_reaction.get_reaction_type().is_empty());
|
|
|
|
if (!are_consistent(reaction_types[message_reaction.get_reaction_type()],
|
2022-09-24 19:15:38 +02:00
|
|
|
message_reaction.get_recent_chooser_dialog_ids())) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
old_total_count += message_reaction.get_choose_count();
|
2023-08-04 17:39:07 +02:00
|
|
|
reaction_types.erase(message_reaction.get_reaction_type());
|
2022-09-24 19:15:38 +02:00
|
|
|
}
|
2023-08-04 17:39:07 +02:00
|
|
|
return old_total_count == total_count && reaction_types.empty();
|
2022-09-24 19:15:38 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// received list and total_count for a single reaction
|
2023-08-04 17:39:07 +02:00
|
|
|
const auto *message_reaction = get_reaction(reaction_type);
|
2022-09-24 19:15:38 +02:00
|
|
|
if (message_reaction == nullptr) {
|
2023-08-04 17:39:07 +02:00
|
|
|
return reaction_types.count(reaction_type) == 0 && total_count == 0;
|
2022-09-24 19:15:38 +02:00
|
|
|
} else {
|
2023-08-04 17:39:07 +02:00
|
|
|
return are_consistent(reaction_types[reaction_type], message_reaction->get_recent_chooser_dialog_ids()) &&
|
2022-09-24 19:15:38 +02:00
|
|
|
message_reaction->get_choose_count() == total_count;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-09-24 19:58:54 +02:00
|
|
|
vector<td_api::object_ptr<td_api::messageReaction>> MessageReactions::get_message_reactions_object(
|
|
|
|
Td *td, UserId my_user_id, UserId peer_user_id) const {
|
|
|
|
return transform(reactions_, [td, my_user_id, peer_user_id](const MessageReaction &reaction) {
|
|
|
|
return reaction.get_message_reaction_object(td, my_user_id, peer_user_id);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2022-09-24 20:09:07 +02:00
|
|
|
void MessageReactions::add_min_channels(Td *td) const {
|
|
|
|
for (const auto &reaction : reactions_) {
|
|
|
|
for (const auto &recent_chooser_min_channel : reaction.get_recent_chooser_min_channels()) {
|
|
|
|
LOG(INFO) << "Add min reacted " << recent_chooser_min_channel.first;
|
|
|
|
td->contacts_manager_->add_min_channel(recent_chooser_min_channel.first, recent_chooser_min_channel.second);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-09-24 20:07:35 +02:00
|
|
|
void MessageReactions::add_dependencies(Dependencies &dependencies) const {
|
|
|
|
for (const auto &reaction : reactions_) {
|
|
|
|
const auto &dialog_ids = reaction.get_recent_chooser_dialog_ids();
|
|
|
|
for (auto dialog_id : dialog_ids) {
|
2023-04-13 22:13:38 +02:00
|
|
|
dependencies.add_message_sender_dependencies(dialog_id);
|
2022-09-24 20:07:35 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-20 20:54:34 +01:00
|
|
|
bool MessageReactions::need_update_message_reactions(const MessageReactions *old_reactions,
|
|
|
|
const MessageReactions *new_reactions) {
|
|
|
|
if (old_reactions == nullptr) {
|
|
|
|
// add reactions
|
|
|
|
return new_reactions != nullptr;
|
|
|
|
}
|
|
|
|
if (new_reactions == nullptr) {
|
|
|
|
// remove reactions when they are disabled
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2022-09-11 12:35:25 +02:00
|
|
|
// unread_reactions_ and chosen_reaction_order_ are updated independently; compare all other fields
|
2022-01-20 20:54:34 +01:00
|
|
|
return old_reactions->reactions_ != new_reactions->reactions_ || old_reactions->is_min_ != new_reactions->is_min_ ||
|
2022-01-30 11:24:27 +01:00
|
|
|
old_reactions->can_get_added_reactions_ != new_reactions->can_get_added_reactions_ ||
|
2022-01-20 20:54:34 +01:00
|
|
|
old_reactions->need_polling_ != new_reactions->need_polling_;
|
|
|
|
}
|
|
|
|
|
2022-01-28 15:10:17 +01:00
|
|
|
bool MessageReactions::need_update_unread_reactions(const MessageReactions *old_reactions,
|
|
|
|
const MessageReactions *new_reactions) {
|
|
|
|
if (old_reactions == nullptr || old_reactions->unread_reactions_.empty()) {
|
|
|
|
return !(new_reactions == nullptr || new_reactions->unread_reactions_.empty());
|
|
|
|
}
|
|
|
|
return new_reactions == nullptr || old_reactions->unread_reactions_ != new_reactions->unread_reactions_;
|
|
|
|
}
|
|
|
|
|
2022-01-30 11:24:27 +01:00
|
|
|
StringBuilder &operator<<(StringBuilder &string_builder, const MessageReactions &reactions) {
|
|
|
|
return string_builder << (reactions.is_min_ ? "Min" : "") << "MessageReactions{" << reactions.reactions_
|
2022-09-11 12:35:25 +02:00
|
|
|
<< " with unread " << reactions.unread_reactions_ << ", reaction order "
|
|
|
|
<< reactions.chosen_reaction_order_
|
2022-01-30 11:24:27 +01:00
|
|
|
<< " and can_get_added_reactions = " << reactions.can_get_added_reactions_;
|
|
|
|
}
|
|
|
|
|
|
|
|
StringBuilder &operator<<(StringBuilder &string_builder, const unique_ptr<MessageReactions> &reactions) {
|
|
|
|
if (reactions == nullptr) {
|
|
|
|
return string_builder << "null";
|
|
|
|
}
|
|
|
|
return string_builder << *reactions;
|
|
|
|
}
|
|
|
|
|
2022-01-26 16:48:46 +01:00
|
|
|
void reload_message_reactions(Td *td, DialogId dialog_id, vector<MessageId> &&message_ids) {
|
2023-03-22 14:44:52 +01:00
|
|
|
if (!td->messages_manager_->have_input_peer(dialog_id, AccessRights::Read) ||
|
|
|
|
dialog_id.get_type() == DialogType::SecretChat || message_ids.empty()) {
|
2023-06-23 13:39:07 +02:00
|
|
|
create_actor<SleepActor>(
|
|
|
|
"RetryReloadMessageReactionsActor", 0.2,
|
|
|
|
PromiseCreator::lambda([actor_id = G()->messages_manager(), dialog_id](Result<Unit> result) mutable {
|
|
|
|
send_closure(actor_id, &MessagesManager::try_reload_message_reactions, dialog_id, true);
|
|
|
|
}))
|
|
|
|
.release();
|
2022-01-26 16:48:46 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (const auto &message_id : message_ids) {
|
|
|
|
CHECK(message_id.is_valid());
|
|
|
|
CHECK(message_id.is_server());
|
|
|
|
}
|
|
|
|
|
|
|
|
td->create_handler<GetMessagesReactionsQuery>()->send(dialog_id, std::move(message_ids));
|
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
void send_message_reaction(Td *td, FullMessageId full_message_id, vector<ReactionType> reaction_types, bool is_big,
|
2022-09-09 15:21:00 +02:00
|
|
|
bool add_to_recent, Promise<Unit> &&promise) {
|
2022-09-05 21:04:50 +02:00
|
|
|
td->create_handler<SendReactionQuery>(std::move(promise))
|
2023-08-04 17:39:07 +02:00
|
|
|
->send(full_message_id, std::move(reaction_types), is_big, add_to_recent);
|
2022-01-21 18:39:55 +01:00
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
void get_message_added_reactions(Td *td, FullMessageId full_message_id, ReactionType reaction_type, string offset,
|
|
|
|
int32 limit, Promise<td_api::object_ptr<td_api::addedReactions>> &&promise) {
|
2022-01-26 23:52:21 +01:00
|
|
|
if (!td->messages_manager_->have_message_force(full_message_id, "get_message_added_reactions")) {
|
2022-01-21 14:46:16 +01:00
|
|
|
return promise.set_error(Status::Error(400, "Message not found"));
|
|
|
|
}
|
|
|
|
|
|
|
|
auto message_id = full_message_id.get_message_id();
|
2022-01-21 18:39:55 +01:00
|
|
|
if (full_message_id.get_dialog_id().get_type() == DialogType::SecretChat || !message_id.is_valid() ||
|
|
|
|
!message_id.is_server()) {
|
2022-01-26 23:52:21 +01:00
|
|
|
return promise.set_value(td_api::make_object<td_api::addedReactions>(0, Auto(), string()));
|
2022-01-21 14:46:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (limit <= 0) {
|
|
|
|
return promise.set_error(Status::Error(400, "Parameter limit must be positive"));
|
|
|
|
}
|
2022-01-26 23:52:21 +01:00
|
|
|
static constexpr int32 MAX_GET_ADDED_REACTIONS = 100; // server side limit
|
|
|
|
if (limit > MAX_GET_ADDED_REACTIONS) {
|
|
|
|
limit = MAX_GET_ADDED_REACTIONS;
|
2022-01-21 14:46:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
td->create_handler<GetMessageReactionsListQuery>(std::move(promise))
|
2023-08-04 17:39:07 +02:00
|
|
|
->send(full_message_id, std::move(reaction_type), std::move(offset), limit);
|
2022-01-21 14:46:16 +01:00
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
void set_default_reaction(Td *td, ReactionType reaction_type, Promise<Unit> &&promise) {
|
|
|
|
if (reaction_type.is_empty()) {
|
2022-08-22 20:29:09 +02:00
|
|
|
return promise.set_error(Status::Error(400, "Default reaction must be non-empty"));
|
|
|
|
}
|
2023-08-04 17:39:07 +02:00
|
|
|
if (!reaction_type.is_custom_reaction() && !td->stickers_manager_->is_active_reaction(reaction_type)) {
|
2022-08-15 21:47:02 +02:00
|
|
|
return promise.set_error(Status::Error(400, "Can't set incative reaction as default"));
|
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
if (td->option_manager_->get_option_string("default_reaction", "-") != reaction_type.get_string()) {
|
|
|
|
td->option_manager_->set_option_string("default_reaction", reaction_type.get_string());
|
2022-08-18 16:00:18 +02:00
|
|
|
if (!td->option_manager_->get_option_boolean("default_reaction_needs_sync")) {
|
|
|
|
td->option_manager_->set_option_boolean("default_reaction_needs_sync", true);
|
2022-08-16 22:08:36 +02:00
|
|
|
send_set_default_reaction_query(td);
|
2022-08-15 21:47:02 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
promise.set_value(Unit());
|
|
|
|
}
|
|
|
|
|
|
|
|
void send_set_default_reaction_query(Td *td) {
|
2023-08-04 17:39:07 +02:00
|
|
|
td->create_handler<SetDefaultReactionQuery>()->send(
|
|
|
|
ReactionType(td->option_manager_->get_option_string("default_reaction")));
|
2022-08-22 14:23:17 +02:00
|
|
|
}
|
|
|
|
|
2022-08-23 13:39:10 +02:00
|
|
|
void report_message_reactions(Td *td, FullMessageId full_message_id, DialogId chooser_dialog_id,
|
|
|
|
Promise<Unit> &&promise) {
|
|
|
|
auto dialog_id = full_message_id.get_dialog_id();
|
|
|
|
if (!td->messages_manager_->have_dialog_force(dialog_id, "send_callback_query")) {
|
|
|
|
return promise.set_error(Status::Error(400, "Chat not found"));
|
|
|
|
}
|
|
|
|
if (!td->messages_manager_->have_input_peer(dialog_id, AccessRights::Read)) {
|
|
|
|
return promise.set_error(Status::Error(400, "Can't access the chat"));
|
|
|
|
}
|
2023-03-22 14:44:52 +01:00
|
|
|
if (dialog_id.get_type() == DialogType::SecretChat) {
|
|
|
|
return promise.set_error(Status::Error(400, "Reactions can't be reported in the chat"));
|
|
|
|
}
|
2022-08-23 13:39:10 +02:00
|
|
|
|
|
|
|
if (!td->messages_manager_->have_message_force(full_message_id, "report_user_reactions")) {
|
|
|
|
return promise.set_error(Status::Error(400, "Message not found"));
|
|
|
|
}
|
|
|
|
auto message_id = full_message_id.get_message_id();
|
|
|
|
if (message_id.is_valid_scheduled()) {
|
|
|
|
return promise.set_error(Status::Error(400, "Can't report reactions on scheduled messages"));
|
|
|
|
}
|
|
|
|
if (!message_id.is_server()) {
|
|
|
|
return promise.set_error(Status::Error(400, "Message reactions can't be reported"));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!td->messages_manager_->have_input_peer(chooser_dialog_id, AccessRights::Know)) {
|
|
|
|
return promise.set_error(Status::Error(400, "Reaction sender not found"));
|
|
|
|
}
|
|
|
|
|
|
|
|
td->create_handler<ReportReactionQuery>(std::move(promise))->send(dialog_id, message_id, chooser_dialog_id);
|
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
vector<ReactionType> get_recent_reactions(Td *td) {
|
2022-09-13 18:19:35 +02:00
|
|
|
return td->stickers_manager_->get_recent_reactions();
|
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
vector<ReactionType> get_top_reactions(Td *td) {
|
2022-09-13 18:19:35 +02:00
|
|
|
return td->stickers_manager_->get_top_reactions();
|
|
|
|
}
|
|
|
|
|
2023-08-04 17:39:07 +02:00
|
|
|
void add_recent_reaction(Td *td, const ReactionType &reaction_type) {
|
|
|
|
td->stickers_manager_->add_recent_reaction(reaction_type);
|
2022-09-12 20:55:30 +02:00
|
|
|
}
|
|
|
|
|
2022-01-20 20:54:34 +01:00
|
|
|
} // namespace td
|