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

Use InputMessageReplyTo in draftMessage.

Browse Source
This commit is contained in:
levlam 2023-10-25 02:07:37 +03:00
parent cfff600a44
commit 5216ea1d01
10 changed files with 125 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
td/generate/scheme/td_api.tl
View File

@ -1441,10 +1441,10 @@ scopeNotificationSettings mute_for:int32 sound_id:int64 show_preview:Bool use_de
//@description Contains information about a message draft
//@reply_to_message_id Identifier of the replied message; 0 if none
//@reply_to Information about the replied message; must be of the type inputMessageReplyToMessage; may be null if none
//@date Point in time (Unix timestamp) when the draft was created
//@input_message_text Content of the message draft; must be of the type inputMessageText
draftMessage reply_to_message_id:int53 date:int32 input_message_text:InputMessageContent = DraftMessage;
draftMessage reply_to:InputMessageReplyTo date:int32 input_message_text:InputMessageContent = DraftMessage;
//@class ChatType @description Describes the type of a chat

58
td/telegram/DraftMessage.cpp
View File

@ -41,22 +41,18 @@ class SaveDraftMessageQuery final : public Td::ResultHandler {
}
int32 flags = 0;
ServerMessageId reply_to_message_id;
telegram_api::object_ptr<telegram_api::InputReplyTo> input_reply_to;
vector<telegram_api::object_ptr<telegram_api::MessageEntity>> input_message_entities;
telegram_api::object_ptr<telegram_api::InputMedia> media;
if (draft_message != nullptr) {
/*
if (draft_message->reply_to_message_id_.is_valid() && draft_message->reply_to_message_id_.is_server()) {
reply_to_message_id = draft_message->reply_to_message_id_.get_server_message_id();
flags |= telegram_api::messages_saveDraft::REPLY_TO_MSG_ID_MASK;
input_reply_to = draft_message->message_input_reply_to_.get_input_reply_to(td_, MessageId() /*TODO*/);
if (input_reply_to != nullptr) {
flags |= telegram_api::messages_saveDraft::REPLY_TO_MASK;
}
*/
if (draft_message->input_message_text_.disable_web_page_preview) {
flags |= telegram_api::messages_saveDraft::NO_WEBPAGE_MASK;
} else {
if (draft_message->input_message_text_.show_above_text) {
flags |= telegram_api::messages_saveDraft::INVERT_MEDIA_MASK;
}
} else if (draft_message->input_message_text_.show_above_text) {
flags |= telegram_api::messages_saveDraft::INVERT_MEDIA_MASK;
}
input_message_entities = get_input_message_entities(
td_->contacts_manager_.get(), draft_message->input_message_text_.text.entities, "SaveDraftMessageQuery");
@ -70,7 +66,7 @@ class SaveDraftMessageQuery final : public Td::ResultHandler {
}
send_query(G()->net_query_creator().create(
telegram_api::messages_saveDraft(
flags, false /*ignored*/, false /*ignored*/, nullptr, std::move(input_peer),
flags, false /*ignored*/, false /*ignored*/, std::move(input_reply_to), std::move(input_peer),
draft_message == nullptr ? string() : draft_message->input_message_text_.text.text,
std::move(input_message_entities), std::move(media)),
{{dialog_id}}));
@ -158,7 +154,7 @@ class ClearAllDraftsQuery final : public Td::ResultHandler {
};
bool DraftMessage::need_update_to(const DraftMessage &other, bool from_update) const {
if (reply_to_message_id_ == other.reply_to_message_id_ && input_message_text_ == other.input_message_text_) {
if (message_input_reply_to_ == other.message_input_reply_to_ && input_message_text_ == other.input_message_text_) {
return date_ < other.date_;
} else {
return !from_update || date_ <= other.date_;
@ -169,25 +165,16 @@ void DraftMessage::add_dependencies(Dependencies &dependencies) const {
input_message_text_.add_dependencies(dependencies);
}
td_api::object_ptr<td_api::draftMessage> DraftMessage::get_draft_message_object() const {
return td_api::make_object<td_api::draftMessage>(reply_to_message_id_.get(), date_,
input_message_text_.get_input_message_text_object());
td_api::object_ptr<td_api::draftMessage> DraftMessage::get_draft_message_object(Td *td, DialogId dialog_id) const {
return td_api::make_object<td_api::draftMessage>(
message_input_reply_to_.get_input_message_reply_to_object(td, dialog_id), date_,
input_message_text_.get_input_message_text_object());
}
DraftMessage::DraftMessage(Td *td, telegram_api::object_ptr<telegram_api::draftMessage> &&draft_message) {
CHECK(draft_message != nullptr);
date_ = draft_message->date_;
/*
auto flags = draft_message->flags_;
if ((flags & telegram_api::draftMessage::REPLY_TO_MSG_ID_MASK) != 0) {
reply_to_message_id_ = MessageId(ServerMessageId(draft_message->reply_to_msg_id_));
if (!reply_to_message_id_.is_valid()) {
LOG(ERROR) << "Receive " << reply_to_message_id_ << " as reply_to_message_id in the draft message";
reply_to_message_id_ = MessageId();
}
}
*/
message_input_reply_to_ = MessageInputReplyTo(td, std::move(draft_message->reply_to_));
auto entities =
get_message_entities(td->contacts_manager_.get(), std::move(draft_message->entities_), "draftMessage");
auto status = fix_formatted_text(draft_message->message_, entities, true, true, true, true, true);
@ -227,16 +214,8 @@ Result<unique_ptr<DraftMessage>> DraftMessage::get_draft_message(
}
auto result = make_unique<DraftMessage>();
result->reply_to_message_id_ = MessageId(draft_message->reply_to_message_id_);
if (result->reply_to_message_id_ != MessageId() && !result->reply_to_message_id_.is_valid()) {
return Status::Error(400, "Invalid reply_to_message_id specified");
}
result->reply_to_message_id_ =
td->messages_manager_
->get_message_input_reply_to(
dialog_id, top_thread_message_id,
td_api::make_object<td_api::inputMessageReplyToMessage>(result->reply_to_message_id_.get()), true)
.message_id_;
result->message_input_reply_to_ = td->messages_manager_->get_message_input_reply_to(
dialog_id, top_thread_message_id, std::move(draft_message->reply_to_), true);
auto input_message_content = std::move(draft_message->input_message_text_);
if (input_message_content != nullptr) {
@ -248,7 +227,7 @@ Result<unique_ptr<DraftMessage>> DraftMessage::get_draft_message(
result->input_message_text_ = std::move(input_message_text);
}
if (!result->reply_to_message_id_.is_valid() && result->input_message_text_.is_empty()) {
if (!result->message_input_reply_to_.is_valid() && result->input_message_text_.is_empty()) {
return nullptr;
}
@ -274,11 +253,12 @@ void add_draft_message_dependencies(Dependencies &dependencies, const unique_ptr
draft_message->add_dependencies(dependencies);
}
td_api::object_ptr<td_api::draftMessage> get_draft_message_object(const unique_ptr<DraftMessage> &draft_message) {
td_api::object_ptr<td_api::draftMessage> get_draft_message_object(Td *td, DialogId dialog_id,
const unique_ptr<DraftMessage> &draft_message) {
if (draft_message == nullptr) {
return nullptr;
}
return draft_message->get_draft_message_object();
return draft_message->get_draft_message_object(td, dialog_id);
}
unique_ptr<DraftMessage> get_draft_message(Td *td,

8
td/telegram/DraftMessage.h
View File

@ -9,6 +9,7 @@
#include "td/telegram/DialogId.h"
#include "td/telegram/InputMessageText.h"
#include "td/telegram/MessageId.h"
#include "td/telegram/MessageInputReplyTo.h"
#include "td/telegram/td_api.h"
#include "td/telegram/telegram_api.h"
@ -24,7 +25,7 @@ class Td;
class DraftMessage {
int32 date_ = 0;
MessageId reply_to_message_id_;
MessageInputReplyTo message_input_reply_to_;
InputMessageText input_message_text_;
friend class SaveDraftMessageQuery;
@ -41,7 +42,7 @@ class DraftMessage {
void add_dependencies(Dependencies &dependencies) const;
td_api::object_ptr<td_api::draftMessage> get_draft_message_object() const;
td_api::object_ptr<td_api::draftMessage> get_draft_message_object(Td *td, DialogId dialog_id) const;
static Result<unique_ptr<DraftMessage>> get_draft_message(Td *td, DialogId dialog_id, MessageId top_thread_message_id,
td_api::object_ptr<td_api::draftMessage> &&draft_message);
@ -58,7 +59,8 @@ bool need_update_draft_message(const unique_ptr<DraftMessage> &old_draft_message
void add_draft_message_dependencies(Dependencies &dependencies, const unique_ptr<DraftMessage> &draft_message);
td_api::object_ptr<td_api::draftMessage> get_draft_message_object(const unique_ptr<DraftMessage> &draft_message);
td_api::object_ptr<td_api::draftMessage> get_draft_message_object(Td *td, DialogId dialog_id,
const unique_ptr<DraftMessage> &draft_message);
unique_ptr<DraftMessage> get_draft_message(Td *td,
telegram_api::object_ptr<telegram_api::DraftMessage> &&draft_message_ptr);

39
td/telegram/DraftMessage.hpp
View File

@ -9,6 +9,7 @@
#include "td/telegram/DraftMessage.h"
#include "td/telegram/InputMessageText.hpp"
#include "td/telegram/MessageInputReplyTo.hpp"
#include "td/utils/tl_helpers.h"
@ -16,16 +17,46 @@ namespace td {
template <class StorerT>
void DraftMessage::store(StorerT &storer) const {
bool has_message_input_reply_to = !message_input_reply_to_.is_empty();
bool has_input_message_text = !input_message_text_.is_empty();
BEGIN_STORE_FLAGS();
STORE_FLAG(has_input_message_text);
STORE_FLAG(has_message_input_reply_to);
END_STORE_FLAGS();
td::store(date_, storer);
td::store(reply_to_message_id_, storer);
td::store(input_message_text_, storer);
if (has_input_message_text) {
td::store(input_message_text_, storer);
}
if (has_message_input_reply_to) {
td::store(message_input_reply_to_, storer);
}
}
template <class ParserT>
void DraftMessage::parse(ParserT &parser) {
bool has_legacy_reply_to_message_id = false;
bool has_message_input_reply_to = false;
bool has_input_message_text = false;
if (parser.version() >= static_cast<int32>(Version::SupportRepliesInOtherChats)) {
BEGIN_PARSE_FLAGS();
PARSE_FLAG(has_input_message_text);
PARSE_FLAG(has_message_input_reply_to);
END_PARSE_FLAGS();
} else {
has_legacy_reply_to_message_id = true;
}
td::parse(date_, parser);
td::parse(reply_to_message_id_, parser);
td::parse(input_message_text_, parser);
if (has_legacy_reply_to_message_id) {
MessageId legacy_reply_to_message_id;
td::parse(legacy_reply_to_message_id, parser);
message_input_reply_to_ = MessageInputReplyTo(legacy_reply_to_message_id);
}
if (has_input_message_text) {
td::parse(input_message_text_, parser);
}
if (has_message_input_reply_to) {
td::parse(message_input_reply_to_, parser);
}
}
} // namespace td

2
td/telegram/ForumTopic.cpp
View File

@ -70,7 +70,7 @@ td_api::object_ptr<td_api::forumTopic> ForumTopic::get_forum_topic_object(Td *td
// TODO draft_message = can_send_message(dialog_id, info_.get_top_thread_message_id()).is_ok() ? ... : nullptr;
auto last_message =
td->messages_manager_->get_message_object({dialog_id, last_message_id_}, "get_forum_topic_object");
auto draft_message = get_draft_message_object(draft_message_);
auto draft_message = get_draft_message_object(td, dialog_id, draft_message_);
return td_api::make_object<td_api::forumTopic>(
info.get_forum_topic_info_object(td), std::move(last_message), is_pinned_, unread_count_,
last_read_inbox_message_id_.get(), last_read_outbox_message_id_.get(), unread_mention_count_,

44
td/telegram/MessageInputReplyTo.cpp
View File

@ -8,6 +8,7 @@
#include "td/telegram/ContactsManager.h"
#include "td/telegram/DialogId.h"
#include "td/telegram/InputDialogId.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/StoryId.h"
#include "td/telegram/Td.h"
@ -36,6 +37,49 @@ MessageInputReplyTo::MessageInputReplyTo(const td_api::object_ptr<td_api::InputM
}
}
*/
MessageInputReplyTo::MessageInputReplyTo(Td *td,
telegram_api::object_ptr<telegram_api::InputReplyTo> &&input_reply_to) {
if (input_reply_to == nullptr) {
return;
}
switch (input_reply_to->get_id()) {
case telegram_api::inputReplyToStory::ID: {
auto reply_to = telegram_api::move_object_as<telegram_api::inputReplyToStory>(input_reply_to);
if (reply_to->user_id_->get_id() != telegram_api::inputUser::ID) {
return;
}
auto user_id = UserId(static_cast<telegram_api::inputUser *>(reply_to->user_id_.get())->user_id_);
auto story_id = StoryId(reply_to->story_id_);
if (user_id.is_valid() && story_id.is_valid()) {
DialogId dialog_id(user_id);
td->messages_manager_->force_create_dialog(dialog_id, "MessageInputReplyTo", true);
story_full_id_ = {dialog_id, story_id};
}
break;
}
case telegram_api::inputReplyToMessage::ID: {
auto reply_to = telegram_api::move_object_as<telegram_api::inputReplyToMessage>(input_reply_to);
MessageId message_id(ServerMessageId(reply_to->reply_to_msg_id_));
if (!message_id.is_valid()) {
return;
}
DialogId dialog_id;
if (reply_to->reply_to_peer_id_ != nullptr) {
dialog_id = InputDialogId(reply_to->reply_to_peer_id_).get_dialog_id();
if (!dialog_id.is_valid()) {
return;
}
}
// TODO quote_text:flags.2?string quote_entities:flags.3?Vector<MessageEntity>
message_id_ = message_id;
break;
}
default:
UNREACHABLE();
}
}
telegram_api::object_ptr<telegram_api::InputReplyTo> MessageInputReplyTo::get_input_reply_to(
Td *td, MessageId top_thread_message_id) const {
if (story_full_id_.is_valid()) {

2
td/telegram/MessageInputReplyTo.h
View File

@ -35,6 +35,8 @@ struct MessageInputReplyTo {
explicit MessageInputReplyTo(StoryFullId story_full_id) : story_full_id_(story_full_id) {
}
MessageInputReplyTo(Td *td, telegram_api::object_ptr<telegram_api::InputReplyTo> &&input_reply_to);
bool is_empty() const {
return !message_id_.is_valid() && !story_full_id_.is_valid();
}

13
td/telegram/MessagesManager.cpp
View File

@ -18031,7 +18031,7 @@ td_api::object_ptr<td_api::messageThreadInfo> MessagesManager::get_message_threa
if (can_send_message(d->dialog_id).is_ok()) {
const Message *m = get_message_force(d, top_thread_message_id, "get_message_thread_info_object 2");
if (m != nullptr && !m->reply_info.is_comment_ && is_active_message_reply_info(d->dialog_id, m->reply_info)) {
draft_message = get_draft_message_object(m->thread_draft_message);
draft_message = get_draft_message_object(td_, d->dialog_id, m->thread_draft_message);
}
}
}
@ -20712,8 +20712,9 @@ td_api::object_ptr<td_api::chat> MessagesManager::get_chat_object(const Dialog *
auto chat_source = is_dialog_sponsored(d) ? sponsored_dialog_source_.get_chat_source_object() : nullptr;
auto can_delete = can_delete_dialog(d);
// TODO hide/show draft message when need_hide_dialog_draft_message changes
auto draft_message =
!need_hide_dialog_draft_message(d->dialog_id) ? get_draft_message_object(d->draft_message) : nullptr;
auto draft_message = !need_hide_dialog_draft_message(d->dialog_id)
? get_draft_message_object(td_, d->dialog_id, d->draft_message)
: nullptr;
auto available_reactions = get_dialog_active_reactions(d).get_chat_available_reactions_object();
auto is_translatable = d->is_translatable && is_premium;
auto block_list_id = BlockListId(d->is_blocked, d->is_blocked_for_stories);
@ -24465,7 +24466,9 @@ MessageInputReplyTo MessagesManager::get_message_input_reply_to(
LOG(INFO) << "Have reply in the thread of unknown " << top_thread_message_id;
}
if (reply_to != nullptr && reply_to->get_id() == td_api::inputMessageReplyToStory::ID) {
CHECK(!for_draft);
if (for_draft) {
return {};
}
auto reply_to_story = td_api::move_object_as<td_api::inputMessageReplyToStory>(reply_to);
auto story_id = StoryId(reply_to_story->story_id_);
auto sender_dialog_id = DialogId(reply_to_story->story_sender_chat_id_);
@ -30219,7 +30222,7 @@ void MessagesManager::send_update_chat_draft_message(const Dialog *d) {
send_closure(G()->td(), &Td::send_update,
td_api::make_object<td_api::updateChatDraftMessage>(
get_chat_id_object(d->dialog_id, "updateChatDraftMessage"),
get_draft_message_object(d->draft_message), get_chat_positions_object(d)));
get_draft_message_object(td_, d->dialog_id, d->draft_message), get_chat_positions_object(d)));
}
}

1
td/telegram/Version.h
View File

@ -64,6 +64,7 @@ enum class Version : int32 {
AddUserFlags2,
AddMessageTextFlags,
AddPageBlockChatLinkFlags, // 50
SupportRepliesInOtherChats,
Next
};

12
td/telegram/cli.cpp
View File

@ -933,6 +933,10 @@ class CliClient final : public Actor {
return {};
}
bool is_empty() const {
return message_id == 0 && story_id == 0;
}
operator td_api::object_ptr<td_api::InputMessageReplyTo>() const {
if (message_id == 0 && user_id == 0 && story_id == 0) {
return nullptr;
@ -4144,19 +4148,19 @@ class CliClient final : public Actor {
if (op == "scdm" || op == "scdmt") {
ChatId chat_id;
MessageThreadId message_thread_id;
string reply_to_message_id;
InputMessageReplyTo reply_to;
string message;
if (op == "scdmt") {
get_args(args, message_thread_id, args);
}
get_args(args, chat_id, reply_to_message_id, message);
get_args(args, chat_id, reply_to, message);
td_api::object_ptr<td_api::draftMessage> draft_message;
if (!reply_to_message_id.empty() || !message.empty()) {
if (!reply_to.is_empty() || !message.empty()) {
vector<td_api::object_ptr<td_api::textEntity>> entities;
entities.push_back(
td_api::make_object<td_api::textEntity>(0, 1, td_api::make_object<td_api::textEntityTypePre>()));
draft_message = td_api::make_object<td_api::draftMessage>(
as_message_id(reply_to_message_id), 0,
reply_to, 0,
td_api::make_object<td_api::inputMessageText>(as_formatted_text(message, std::move(entities)), nullptr,
false));
}