128 lines
5.3 KiB
C++
128 lines
5.3 KiB
C++
//
|
|
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2023
|
|
//
|
|
// 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/MessageOrigin.h"
|
|
|
|
#include "td/telegram/ChannelId.h"
|
|
#include "td/telegram/ContactsManager.h"
|
|
#include "td/telegram/Global.h"
|
|
#include "td/telegram/MessagesManager.h"
|
|
#include "td/telegram/Td.h"
|
|
|
|
#include "td/utils/logging.h"
|
|
|
|
namespace td {
|
|
|
|
Result<MessageOrigin> MessageOrigin::get_message_origin(
|
|
Td *td, telegram_api::object_ptr<telegram_api::messageFwdHeader> &&forward_header) {
|
|
CHECK(forward_header != nullptr);
|
|
DialogId sender_dialog_id;
|
|
if (forward_header->from_id_ != nullptr) {
|
|
sender_dialog_id = DialogId(forward_header->from_id_);
|
|
if (!sender_dialog_id.is_valid()) {
|
|
LOG(ERROR) << "Receive invalid sender identifier in message forward header: "
|
|
<< oneline(to_string(forward_header));
|
|
sender_dialog_id = DialogId();
|
|
}
|
|
}
|
|
|
|
MessageId message_id;
|
|
if (forward_header->channel_post_ != 0) {
|
|
message_id = MessageId(ServerMessageId(forward_header->channel_post_));
|
|
if (!message_id.is_valid()) {
|
|
LOG(ERROR) << "Receive " << message_id << " in message forward header: " << oneline(to_string(forward_header));
|
|
message_id = MessageId();
|
|
}
|
|
}
|
|
|
|
string author_signature = std::move(forward_header->post_author_);
|
|
string sender_name = std::move(forward_header->from_name_);
|
|
|
|
UserId sender_user_id;
|
|
if (sender_dialog_id.get_type() == DialogType::User) {
|
|
sender_user_id = sender_dialog_id.get_user_id();
|
|
sender_dialog_id = DialogId();
|
|
}
|
|
if (!sender_dialog_id.is_valid()) {
|
|
if (sender_user_id.is_valid()) {
|
|
if (message_id.is_valid()) {
|
|
LOG(ERROR) << "Receive non-empty message identifier in message forward header: "
|
|
<< oneline(to_string(forward_header));
|
|
message_id = MessageId();
|
|
}
|
|
} else if (sender_name.empty()) {
|
|
LOG(ERROR) << "Receive wrong message forward header: " << oneline(to_string(forward_header));
|
|
return Status::Error("Receive empty forward header");
|
|
}
|
|
} else if (sender_dialog_id.get_type() != DialogType::Channel) {
|
|
LOG(ERROR) << "Receive wrong message forward header with non-channel sender: "
|
|
<< oneline(to_string(forward_header));
|
|
return Status::Error("Forward from a non-channel");
|
|
} else {
|
|
auto channel_id = sender_dialog_id.get_channel_id();
|
|
if (!td->contacts_manager_->have_channel(channel_id)) {
|
|
LOG(ERROR) << "Receive forward from " << (td->contacts_manager_->have_min_channel(channel_id) ? "min" : "unknown")
|
|
<< ' ' << channel_id;
|
|
}
|
|
td->messages_manager_->force_create_dialog(sender_dialog_id, "get_message_origin", true);
|
|
CHECK(!sender_user_id.is_valid());
|
|
}
|
|
|
|
return MessageOrigin{sender_user_id, sender_dialog_id, message_id, std::move(author_signature),
|
|
std::move(sender_name)};
|
|
}
|
|
|
|
td_api::object_ptr<td_api::MessageForwardOrigin> MessageOrigin::get_message_forward_origin_object(const Td *td) const {
|
|
if (is_sender_hidden()) {
|
|
return td_api::make_object<td_api::messageForwardOriginHiddenUser>(sender_name_.empty() ? author_signature_
|
|
: sender_name_);
|
|
}
|
|
if (message_id_.is_valid()) {
|
|
return td_api::make_object<td_api::messageForwardOriginChannel>(
|
|
td->messages_manager_->get_chat_id_object(sender_dialog_id_, "messageForwardOriginChannel"), message_id_.get(),
|
|
author_signature_);
|
|
}
|
|
if (sender_dialog_id_.is_valid()) {
|
|
return td_api::make_object<td_api::messageForwardOriginChat>(
|
|
td->messages_manager_->get_chat_id_object(sender_dialog_id_, "messageForwardOriginChat"),
|
|
sender_name_.empty() ? author_signature_ : sender_name_);
|
|
}
|
|
return td_api::make_object<td_api::messageForwardOriginUser>(
|
|
td->contacts_manager_->get_user_id_object(sender_user_id_, "messageForwardOriginUser"));
|
|
}
|
|
|
|
bool MessageOrigin::is_sender_hidden() const {
|
|
if (!sender_name_.empty()) {
|
|
return true;
|
|
}
|
|
DialogId hidden_sender_dialog_id(ChannelId(static_cast<int64>(G()->is_test_dc() ? 10460537 : 1228946795)));
|
|
return sender_dialog_id_ == hidden_sender_dialog_id && !author_signature_.empty() && !message_id_.is_valid();
|
|
}
|
|
|
|
bool operator==(const MessageOrigin &lhs, const MessageOrigin &rhs) {
|
|
return lhs.sender_user_id_ == rhs.sender_user_id_ && lhs.sender_dialog_id_ == rhs.sender_dialog_id_ &&
|
|
lhs.message_id_ == rhs.message_id_ && lhs.author_signature_ == rhs.author_signature_ &&
|
|
lhs.sender_name_ == rhs.sender_name_;
|
|
}
|
|
|
|
StringBuilder &operator<<(StringBuilder &string_builder, const MessageOrigin &origin) {
|
|
string_builder << "sender " << origin.sender_user_id_;
|
|
if (!origin.author_signature_.empty() || !origin.sender_name_.empty()) {
|
|
string_builder << '(' << origin.author_signature_ << '/' << origin.sender_name_ << ')';
|
|
}
|
|
if (origin.sender_dialog_id_.is_valid()) {
|
|
string_builder << ", source ";
|
|
if (origin.message_id_.is_valid()) {
|
|
string_builder << MessageFullId(origin.sender_dialog_id_, origin.message_id_);
|
|
} else {
|
|
string_builder << origin.sender_dialog_id_;
|
|
}
|
|
}
|
|
return string_builder;
|
|
}
|
|
|
|
} // namespace td
|