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

Add more information to forwardSource.

Browse Source
This commit is contained in:
levlam 2024-01-12 00:23:33 +03:00
parent 91aef01e7e
commit 2ff04387b8
5 changed files with 118 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1181,10 +1181,14 @@ messageOriginChat sender_chat_id:int53 author_signature:string = MessageOrigin;
messageOriginChannel chat_id:int53 message_id:int53 author_signature:string = MessageOrigin;
//@description Contains information about the last message from which the new message was forwarded last time
//@chat_id Identifier of the chat from which the message was forwarded last time
//@message_id Identifier of the source message from which the message was forwarded last time
forwardSource chat_id:int53 message_id:int53 = ForwardSource;
//@description Contains information about the last message from which a new message was forwarded last time
//@chat_id Identifier of the chat to which the message that was forwarded belonged
//@message_id Identifier of the message
//@sender_id Identifier of the sender of the message; may be null if unknown or the new message was forwarded not to Saved Messages
//@sender_name Name of the sender of the message if the sender is hidden by their privacy settings
//@date Point in time (Unix timestamp) when the message is sent; 0 if unknown
//@is_outgoing True, if the message that was forwarded is outgoing; always false if sender is unknown
forwardSource chat_id:int53 message_id:int53 sender_id:MessageSender sender_name:string date:int32 is_outgoing:Bool = ForwardSource;
//@class ReactionType @description Describes type of message reaction

65
td/telegram/MessageForwardInfo.cpp
View File

@ -6,8 +6,10 @@
//
#include "td/telegram/MessageForwardInfo.h"
#include "td/telegram/ContactsManager.h"
#include "td/telegram/Dependencies.h"
#include "td/telegram/DialogManager.h"
#include "td/telegram/MessageSender.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/Td.h"
@ -16,46 +18,72 @@
namespace td {
bool LastForwardedMessageInfo::is_empty() const {
return dialog_id_ == DialogId() && message_id_ == MessageId();
return *this == LastForwardedMessageInfo();
}
bool LastForwardedMessageInfo::validate() {
if (is_empty()) {
return true;
}
if (!dialog_id_.is_valid() || !message_id_.is_valid()) {
if (!dialog_id_.is_valid() || !message_id_.is_valid() ||
(sender_dialog_id_ != DialogId() && !sender_dialog_id_.is_valid()) ||
((sender_dialog_id_ != DialogId() || !sender_name_.empty()) && date_ <= 0)) {
*this = {};
return false;
}
return true;
}
void LastForwardedMessageInfo::hide_sender_if_needed(Td *td) {
if (sender_name_.empty() && sender_dialog_id_.get_type() == DialogType::User) {
auto private_forward_name = td->contacts_manager_->get_user_private_forward_name(sender_dialog_id_.get_user_id());
if (!private_forward_name.empty()) {
sender_dialog_id_ = DialogId();
sender_name_ = std::move(private_forward_name);
}
}
}
void LastForwardedMessageInfo::add_dependencies(Dependencies &dependencies) const {
dependencies.add_dialog_and_dependencies(dialog_id_);
dependencies.add_message_sender_dependencies(sender_dialog_id_);
}
void LastForwardedMessageInfo::add_min_user_ids(vector<UserId> &user_ids) const {
if (dialog_id_.get_type() == DialogType::User) {
user_ids.push_back(dialog_id_.get_user_id());
}
if (sender_dialog_id_.get_type() == DialogType::User) {
user_ids.push_back(sender_dialog_id_.get_user_id());
}
}
void LastForwardedMessageInfo::add_min_channel_ids(vector<ChannelId> &channel_ids) const {
if (dialog_id_.get_type() == DialogType::Channel) {
channel_ids.push_back(dialog_id_.get_channel_id());
}
if (sender_dialog_id_.get_type() == DialogType::Channel) {
channel_ids.push_back(sender_dialog_id_.get_channel_id());
}
}
td_api::object_ptr<td_api::forwardSource> LastForwardedMessageInfo::get_forward_source_object(Td *td) const {
if (is_empty()) {
return nullptr;
}
td_api::object_ptr<td_api::MessageSender> sender_id;
if (sender_dialog_id_ != DialogId()) {
sender_id = get_message_sender_object_const(td, sender_dialog_id_, "forwardSource.sender_id");
}
return td_api::make_object<td_api::forwardSource>(
td->messages_manager_->get_chat_id_object(dialog_id_, "forwardSource"), message_id_.get());
td->messages_manager_->get_chat_id_object(dialog_id_, "forwardSource.chat_id"), message_id_.get(),
std::move(sender_id), sender_name_, date_, is_outgoing_);
}
bool operator==(const LastForwardedMessageInfo &lhs, const LastForwardedMessageInfo &rhs) {
return lhs.dialog_id_ == rhs.dialog_id_ && lhs.message_id_ == rhs.message_id_;
return lhs.dialog_id_ == rhs.dialog_id_ && lhs.message_id_ == rhs.message_id_ &&
lhs.sender_dialog_id_ == rhs.sender_dialog_id_ && lhs.sender_name_ == rhs.sender_name_ &&
lhs.date_ == rhs.date_ && lhs.is_outgoing_ == rhs.is_outgoing_;
}
bool operator!=(const LastForwardedMessageInfo &lhs, const LastForwardedMessageInfo &rhs) {
@ -63,10 +91,19 @@ bool operator!=(const LastForwardedMessageInfo &lhs, const LastForwardedMessageI
}
StringBuilder &operator<<(StringBuilder &string_builder, const LastForwardedMessageInfo &last_message_info) {
if (last_message_info.is_empty()) {
return string_builder;
if (!last_message_info.is_empty()) {
string_builder << MessageFullId(last_message_info.dialog_id_, last_message_info.message_id_);
if (last_message_info.sender_dialog_id_ != DialogId() || !last_message_info.sender_name_.empty()) {
string_builder << " sent by " << last_message_info.sender_dialog_id_ << '/' << last_message_info.sender_name_;
if (last_message_info.is_outgoing_) {
string_builder << " (me)";
}
}
if (last_message_info.date_ != 0) {
string_builder << " at " << last_message_info.date_;
}
}
return string_builder << MessageFullId(last_message_info.dialog_id_, last_message_info.message_id_);
return string_builder;
}
unique_ptr<MessageForwardInfo> MessageForwardInfo::get_message_forward_info(
@ -82,8 +119,14 @@ unique_ptr<MessageForwardInfo> MessageForwardInfo::get_message_forward_info(
LastForwardedMessageInfo last_message_info;
if (forward_header->saved_from_peer_ != nullptr) {
last_message_info = LastForwardedMessageInfo(DialogId(forward_header->saved_from_peer_),
MessageId(ServerMessageId(forward_header->saved_from_msg_id_)));
DialogId sender_dialog_id;
if (forward_header->saved_from_id_ != nullptr) {
sender_dialog_id = DialogId(forward_header->saved_from_id_);
}
last_message_info = LastForwardedMessageInfo(
DialogId(forward_header->saved_from_peer_), MessageId(ServerMessageId(forward_header->saved_from_msg_id_)),
sender_dialog_id, std::move(forward_header->saved_from_name_), forward_header->saved_date_,
forward_header->saved_out_ || sender_dialog_id == td->dialog_manager_->get_my_dialog_id());
if (last_message_info.is_empty() || !last_message_info.validate()) {
LOG(ERROR) << "Receive wrong last message in message forward header: " << oneline(to_string(forward_header));
} else {
@ -108,6 +151,7 @@ unique_ptr<MessageForwardInfo> MessageForwardInfo::get_message_forward_info(
unique_ptr<MessageForwardInfo> MessageForwardInfo::copy_message_forward_info(
Td *td, const MessageForwardInfo &forward_info, LastForwardedMessageInfo &&last_message_info) {
last_message_info.validate();
last_message_info.hide_sender_if_needed(td);
auto result = make_unique<MessageForwardInfo>(forward_info);
result->last_message_info_ = std::move(last_message_info);
@ -155,7 +199,8 @@ bool MessageForwardInfo::need_change_warning(const MessageForwardInfo *lhs, cons
return true;
}
// yet unsent or scheduled messages can change sender name or author signature when being sent
return !lhs->origin_.has_sender_signature() && !rhs->origin_.has_sender_signature();
return !lhs->origin_.has_sender_signature() && !rhs->origin_.has_sender_signature() &&
!lhs->last_message_info_.has_sender_name() && !rhs->last_message_info_.has_sender_name();
}
bool operator==(const MessageForwardInfo &lhs, const MessageForwardInfo &rhs) {

19
td/telegram/MessageForwardInfo.h
View File

@ -26,6 +26,10 @@ class Td;
class LastForwardedMessageInfo {
DialogId dialog_id_;
MessageId message_id_;
DialogId sender_dialog_id_;
string sender_name_;
int32 date_ = 0;
bool is_outgoing_ = false;
friend bool operator==(const LastForwardedMessageInfo &lhs, const LastForwardedMessageInfo &rhs);
@ -34,13 +38,22 @@ class LastForwardedMessageInfo {
public:
LastForwardedMessageInfo() = default;
LastForwardedMessageInfo(DialogId dialog_id, MessageId message_id) : dialog_id_(dialog_id), message_id_(message_id) {
LastForwardedMessageInfo(DialogId dialog_id, MessageId message_id, DialogId sender_dialog_id, string sender_name,
int32 date, bool is_outgoing)
: dialog_id_(dialog_id)
, message_id_(message_id)
, sender_dialog_id_(sender_dialog_id)
, sender_name_(std::move(sender_name))
, date_(date)
, is_outgoing_(is_outgoing) {
}
bool is_empty() const;
bool validate();
void hide_sender_if_needed(Td *td);
void add_dependencies(Dependencies &dependencies) const;
void add_min_user_ids(vector<UserId> &user_ids) const;
@ -57,6 +70,10 @@ class LastForwardedMessageInfo {
return {dialog_id_, message_id_};
}
bool has_sender_name() const {
return !sender_name_.empty();
}
template <class StorerT>
void store(StorerT &storer) const;

33
td/telegram/MessageForwardInfo.hpp
View File

@ -18,18 +18,51 @@ namespace td {
template <class StorerT>
void LastForwardedMessageInfo::store(StorerT &storer) const {
bool has_sender_dialog_id = sender_dialog_id_.is_valid();
bool has_sender_name = !sender_name_.empty();
bool has_date = date_ > 0;
BEGIN_STORE_FLAGS();
STORE_FLAG(has_sender_dialog_id);
STORE_FLAG(has_sender_name);
STORE_FLAG(has_date);
STORE_FLAG(is_outgoing_);
END_STORE_FLAGS();
td::store(dialog_id_, storer);
td::store(message_id_, storer);
if (has_sender_dialog_id) {
td::store(sender_dialog_id_, storer);
}
if (has_sender_name) {
td::store(sender_name_, storer);
}
if (has_date) {
td::store(date_, storer);
}
}
template <class ParserT>
void LastForwardedMessageInfo::parse(ParserT &parser) {
bool has_sender_dialog_id;
bool has_sender_name;
bool has_date;
BEGIN_PARSE_FLAGS();
PARSE_FLAG(has_sender_dialog_id);
PARSE_FLAG(has_sender_name);
PARSE_FLAG(has_date);
PARSE_FLAG(is_outgoing_);
END_PARSE_FLAGS();
td::parse(dialog_id_, parser);
td::parse(message_id_, parser);
if (has_sender_dialog_id) {
td::parse(sender_dialog_id_, parser);
}
if (has_sender_name) {
td::parse(sender_name_, parser);
}
if (has_date) {
td::parse(date_, parser);
}
validate();
}

6
td/telegram/MessagesManager.cpp
View File

@ -4290,7 +4290,8 @@ void MessagesManager::Message::parse(ParserT &parser) {
MessageId forward_from_message_id;
parse(forward_from_dialog_id, parser);
parse(forward_from_message_id, parser);
last_message_info = LastForwardedMessageInfo(forward_from_dialog_id, forward_from_message_id);
last_message_info =
LastForwardedMessageInfo(forward_from_dialog_id, forward_from_message_id, DialogId(), string(), 0, false);
}
string psa_type;
if (legacy_has_forward_psa_type) {
@ -25816,7 +25817,8 @@ unique_ptr<MessageForwardInfo> MessagesManager::create_message_forward_info(Dial
LastForwardedMessageInfo last_message_info;
if (to_dialog_id == my_dialog_id) {
last_message_info = LastForwardedMessageInfo(from_dialog_id, m->message_id);
last_message_info = LastForwardedMessageInfo(from_dialog_id, m->message_id, get_message_sender(m), string(),
m->date, m->is_outgoing);
} else if (content_type == MessageContentType::Audio || content_type == MessageContentType::Story) {
return nullptr;
}