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

Use FullMessageId in get_login_button_url.

This commit is contained in:
levlam 2021-06-03 23:37:56 +03:00
parent fa7ce9b94d
commit a96bf1531a
5 changed files with 34 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
td/telegram/LinkManager.cpp
View File

@ -11,6 +11,7 @@
#include "td/telegram/ConfigManager.h"
#include "td/telegram/ConfigShared.h"
#include "td/telegram/ContactsManager.h"
#include "td/telegram/DialogId.h"
#include "td/telegram/Global.h"
#include "td/telegram/MessageEntity.h"
#include "td/telegram/MessagesManager.h"
@ -336,20 +337,21 @@ class RequestUrlAuthQuery : public Td::ResultHandler {
: promise_(std::move(promise)) {
}
void send(string url, DialogId dialog_id, MessageId message_id, int32 button_id) {
void send(string url, FullMessageId full_message_id, int32 button_id) {
url_ = std::move(url);
int32 flags = 0;
tl_object_ptr<telegram_api::InputPeer> input_peer;
if (dialog_id.is_valid()) {
dialog_id_ = dialog_id;
input_peer = td->messages_manager_->get_input_peer(dialog_id, AccessRights::Read);
if (full_message_id.get_dialog_id().is_valid()) {
dialog_id_ = full_message_id.get_dialog_id();
input_peer = td->messages_manager_->get_input_peer(dialog_id_, AccessRights::Read);
CHECK(input_peer != nullptr);
flags |= telegram_api::messages_requestUrlAuth::PEER_MASK;
} else {
flags |= telegram_api::messages_requestUrlAuth::URL_MASK;
}
send_query(G()->net_query_creator().create(telegram_api::messages_requestUrlAuth(
flags, std::move(input_peer), message_id.get_server_message_id().get(), button_id, url_)));
flags, std::move(input_peer), full_message_id.get_message_id().get_server_message_id().get(), button_id,
url_)));
}
void on_result(uint64 id, BufferSlice packet) override {
@ -404,13 +406,13 @@ class AcceptUrlAuthQuery : public Td::ResultHandler {
explicit AcceptUrlAuthQuery(Promise<td_api::object_ptr<td_api::httpUrl>> &&promise) : promise_(std::move(promise)) {
}
void send(string url, DialogId dialog_id, MessageId message_id, int32 button_id, bool allow_write_access) {
void send(string url, FullMessageId full_message_id, int32 button_id, bool allow_write_access) {
url_ = std::move(url);
int32 flags = 0;
tl_object_ptr<telegram_api::InputPeer> input_peer;
if (dialog_id.is_valid()) {
dialog_id_ = dialog_id;
input_peer = td->messages_manager_->get_input_peer(dialog_id, AccessRights::Read);
if (full_message_id.get_dialog_id().is_valid()) {
dialog_id_ = full_message_id.get_dialog_id();
input_peer = td->messages_manager_->get_input_peer(dialog_id_, AccessRights::Read);
CHECK(input_peer != nullptr);
flags |= telegram_api::messages_acceptUrlAuth::PEER_MASK;
} else {
@ -420,7 +422,8 @@ class AcceptUrlAuthQuery : public Td::ResultHandler {
flags |= telegram_api::messages_acceptUrlAuth::WRITE_ALLOWED_MASK;
}
send_query(G()->net_query_creator().create(telegram_api::messages_acceptUrlAuth(
flags, false /*ignored*/, std::move(input_peer), message_id.get_server_message_id().get(), button_id, url_)));
flags, false /*ignored*/, std::move(input_peer), full_message_id.get_message_id().get_server_message_id().get(),
button_id, url_)));
}
void on_result(uint64 id, BufferSlice packet) override {
@ -1016,7 +1019,7 @@ void LinkManager::get_external_link_info(string &&link, Promise<td_api::object_p
if (!td::contains(autologin_domains_, r_url.ok().host_)) {
if (td::contains(url_auth_domains_, r_url.ok().host_)) {
td_->create_handler<RequestUrlAuthQuery>(std::move(promise))->send(link, DialogId(), MessageId(), 0);
td_->create_handler<RequestUrlAuthQuery>(std::move(promise))->send(link, FullMessageId(), 0);
return;
}
return promise.set_value(std::move(default_result));
@ -1062,23 +1065,22 @@ void LinkManager::get_external_link_info(string &&link, Promise<td_api::object_p
promise.set_value(td_api::make_object<td_api::loginUrlInfoOpen>(url.get_url(), false));
}
void LinkManager::get_login_url_info(DialogId dialog_id, MessageId message_id, int32 button_id,
void LinkManager::get_login_url_info(FullMessageId full_message_id, int32 button_id,
Promise<td_api::object_ptr<td_api::LoginUrlInfo>> &&promise) {
TRY_RESULT_PROMISE(promise, url, td_->messages_manager_->get_login_button_url(dialog_id, message_id, button_id));
td_->create_handler<RequestUrlAuthQuery>(std::move(promise))->send(std::move(url), dialog_id, message_id, button_id);
TRY_RESULT_PROMISE(promise, url, td_->messages_manager_->get_login_button_url(full_message_id, button_id));
td_->create_handler<RequestUrlAuthQuery>(std::move(promise))->send(std::move(url), full_message_id, button_id);
}
void LinkManager::get_login_url(DialogId dialog_id, MessageId message_id, int32 button_id, bool allow_write_access,
void LinkManager::get_login_url(FullMessageId full_message_id, int32 button_id, bool allow_write_access,
Promise<td_api::object_ptr<td_api::httpUrl>> &&promise) {
TRY_RESULT_PROMISE(promise, url, td_->messages_manager_->get_login_button_url(dialog_id, message_id, button_id));
TRY_RESULT_PROMISE(promise, url, td_->messages_manager_->get_login_button_url(full_message_id, button_id));
td_->create_handler<AcceptUrlAuthQuery>(std::move(promise))
->send(std::move(url), dialog_id, message_id, button_id, allow_write_access);
->send(std::move(url), full_message_id, button_id, allow_write_access);
}
void LinkManager::get_link_login_url(const string &url, bool allow_write_access,
Promise<td_api::object_ptr<td_api::httpUrl>> &&promise) {
td_->create_handler<AcceptUrlAuthQuery>(std::move(promise))
->send(url, DialogId(), MessageId(), 0, allow_write_access);
td_->create_handler<AcceptUrlAuthQuery>(std::move(promise))->send(url, FullMessageId(), 0, allow_write_access);
}
string LinkManager::get_dialog_invite_link_hash(Slice invite_link) {

7
td/telegram/LinkManager.h
View File

@ -6,8 +6,7 @@
//
#pragma once
#include "td/telegram/DialogId.h"
#include "td/telegram/MessageId.h"
#include "td/telegram/FullMessageId.h"
#include "td/telegram/MessageLinkInfo.h"
#include "td/telegram/td_api.h"
@ -57,10 +56,10 @@ class LinkManager : public Actor {
void get_external_link_info(string &&link, Promise<td_api::object_ptr<td_api::LoginUrlInfo>> &&promise);
void get_login_url_info(DialogId dialog_id, MessageId message_id, int32 button_id,
void get_login_url_info(FullMessageId full_message_id, int32 button_id,
Promise<td_api::object_ptr<td_api::LoginUrlInfo>> &&promise);
void get_login_url(DialogId dialog_id, MessageId message_id, int32 button_id, bool allow_write_access,
void get_login_url(FullMessageId full_message_id, int32 button_id, bool allow_write_access,
Promise<td_api::object_ptr<td_api::httpUrl>> &&promise);
void get_link_login_url(const string &url, bool allow_write_access,

14
td/telegram/MessagesManager.cpp
View File

@ -8459,30 +8459,30 @@ void MessagesManager::get_dialog_statistics_url(DialogId dialog_id, const string
td_->create_handler<GetStatsUrlQuery>(std::move(promise))->send(dialog_id, parameters, is_dark);
}
Result<string> MessagesManager::get_login_button_url(DialogId dialog_id, MessageId message_id, int32 button_id) {
Dialog *d = get_dialog_force(dialog_id, "get_login_button_url");
Result<string> MessagesManager::get_login_button_url(FullMessageId full_message_id, int32 button_id) {
Dialog *d = get_dialog_force(full_message_id.get_dialog_id(), "get_login_button_url");
if (d == nullptr) {
return Status::Error(3, "Chat not found");
}
if (!have_input_peer(dialog_id, AccessRights::Read)) {
if (!have_input_peer(d->dialog_id, AccessRights::Read)) {
return Status::Error(3, "Can't access the chat");
}
auto m = get_message_force(d, message_id, "get_login_button_url");
auto m = get_message_force(d, full_message_id.get_message_id(), "get_login_button_url");
if (m == nullptr) {
return Status::Error(5, "Message not found");
}
if (m->reply_markup == nullptr || m->reply_markup->type != ReplyMarkup::Type::InlineKeyboard) {
return Status::Error(5, "Message has no inline keyboard");
}
if (message_id.is_scheduled()) {
if (m->message_id.is_scheduled()) {
return Status::Error(5, "Can't use login buttons from scheduled messages");
}
if (!message_id.is_server()) {
if (!m->message_id.is_server()) {
// it shouldn't have UrlAuth buttons anyway
return Status::Error(5, "Message is not server");
}
if (dialog_id.get_type() == DialogType::SecretChat) {
if (d->dialog_id.get_type() == DialogType::SecretChat) {
// secret chat messages can't have reply markup, so this shouldn't happen now
return Status::Error(5, "Message is in a secret chat");
}

2
td/telegram/MessagesManager.h
View File

@ -891,7 +891,7 @@ class MessagesManager : public Actor {
void stop_poll(FullMessageId full_message_id, td_api::object_ptr<td_api::ReplyMarkup> &&reply_markup,
Promise<Unit> &&promise);
Result<string> get_login_button_url(DialogId dialog_id, MessageId message_id, int32 button_id);
Result<string> get_login_button_url(FullMessageId full_message_id, int32 button_id);
Result<ServerMessageId> get_invoice_message_id(FullMessageId full_message_id);

4
td/telegram/Td.cpp
View File

@ -7740,14 +7740,14 @@ void Td::on_request(uint64 id, const td_api::hideSuggestedAction &request) {
void Td::on_request(uint64 id, const td_api::getLoginUrlInfo &request) {
CHECK_IS_USER();
CREATE_REQUEST_PROMISE();
link_manager_->get_login_url_info(DialogId(request.chat_id_), MessageId(request.message_id_), request.button_id_,
link_manager_->get_login_url_info({DialogId(request.chat_id_), MessageId(request.message_id_)}, request.button_id_,
std::move(promise));
}
void Td::on_request(uint64 id, const td_api::getLoginUrl &request) {
CHECK_IS_USER();
CREATE_REQUEST_PROMISE();
link_manager_->get_login_url(DialogId(request.chat_id_), MessageId(request.message_id_), request.button_id_,
link_manager_->get_login_url({DialogId(request.chat_id_), MessageId(request.message_id_)}, request.button_id_,
request.allow_write_access_, std::move(promise));
}