tdesktop/Telegram/SourceFiles/api/api_sending.cpp

489 lines
14 KiB
C++
Raw Normal View History

2019-07-17 14:34:39 +00:00
/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.
For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#include "api/api_sending.h"
2019-09-16 11:14:06 +00:00
#include "api/api_text_entities.h"
#include "base/random.h"
2019-07-17 14:34:39 +00:00
#include "base/unixtime.h"
#include "data/data_document.h"
#include "data/data_photo.h"
#include "data/data_channel.h" // ChannelData::addsSignature.
#include "data/data_user.h" // UserData::name
2019-07-17 14:34:39 +00:00
#include "data/data_session.h"
#include "data/data_file_origin.h"
#include "data/data_histories.h"
2020-06-12 14:09:04 +00:00
#include "data/data_changes.h"
#include "data/stickers/data_stickers.h"
2019-07-17 14:34:39 +00:00
#include "history/history.h"
#include "history/history_message.h" // NewMessageFlags.
#include "chat_helpers/message_field.h" // ConvertTextTagsToEntities.
2020-10-14 13:01:07 +00:00
#include "chat_helpers/stickers_dice_pack.h" // DicePacks::kDiceString.
2019-07-17 14:34:39 +00:00
#include "ui/text/text_entity.h" // TextWithEntities.
2020-10-10 09:15:37 +00:00
#include "ui/item_text_options.h" // Ui::ItemTextOptions.
2019-07-24 11:45:24 +00:00
#include "main/main_session.h"
2020-04-20 09:45:59 +00:00
#include "main/main_account.h"
#include "main/main_app_config.h"
2020-06-12 14:09:04 +00:00
#include "storage/localimageloader.h"
#include "storage/file_upload.h"
2019-07-17 14:34:39 +00:00
#include "mainwidget.h"
#include "apiwrap.h"
namespace Api {
namespace {
void InnerFillMessagePostFlags(
2021-11-18 07:03:03 +00:00
const SendOptions &options,
not_null<PeerData*> peer,
2021-07-28 11:55:02 +00:00
MessageFlags &flags) {
2020-09-10 11:19:48 +00:00
const auto anonymousPost = peer->amAnonymous();
if (!anonymousPost) {
2021-07-28 11:55:02 +00:00
flags |= MessageFlag::HasFromId;
return;
2020-09-10 11:19:48 +00:00
} else if (peer->asMegagroup()) {
return;
}
2021-07-28 11:55:02 +00:00
flags |= MessageFlag::Post;
// Don't display views and author of a new post when it's scheduled.
if (options.scheduled) {
return;
}
2021-07-28 11:55:02 +00:00
flags |= MessageFlag::HasViews;
if (peer->asChannel()->addsSignature()) {
2021-07-28 11:55:02 +00:00
flags |= MessageFlag::HasPostAuthor;
}
}
2019-07-17 14:34:39 +00:00
template <typename MediaData>
void SendExistingMedia(
2021-11-18 07:03:03 +00:00
MessageToSend &&message,
2019-07-17 14:34:39 +00:00
not_null<MediaData*> media,
Fn<MTPInputMedia()> inputMedia,
Data::FileOrigin origin) {
const auto history = message.action.history;
2019-07-17 14:34:39 +00:00
const auto peer = history->peer;
const auto session = &history->session();
const auto api = &session->api();
message.action.clearDraft = false;
message.action.generateLocal = true;
api->sendAction(message.action);
2019-07-17 14:34:39 +00:00
2019-08-12 16:33:36 +00:00
const auto newId = FullMsgId(
peerToChannel(peer->id),
session->data().nextLocalMessageId());
const auto randomId = base::RandomValue<uint64>();
2019-07-17 14:34:39 +00:00
2021-07-28 11:55:02 +00:00
auto flags = NewMessageFlags(peer);
2019-07-17 14:34:39 +00:00
auto sendFlags = MTPmessages_SendMedia::Flags(0);
if (message.action.replyTo) {
2021-07-28 11:55:02 +00:00
flags |= MessageFlag::HasReplyInfo;
2019-07-17 14:34:39 +00:00
sendFlags |= MTPmessages_SendMedia::Flag::f_reply_to_msg_id;
}
2020-09-10 11:19:48 +00:00
const auto anonymousPost = peer->amAnonymous();
const auto silentPost = ShouldSendSilent(peer, message.action.options);
InnerFillMessagePostFlags(message.action.options, peer, flags);
2019-07-17 14:34:39 +00:00
if (silentPost) {
sendFlags |= MTPmessages_SendMedia::Flag::f_silent;
}
2021-11-09 15:24:13 +00:00
const auto sendAs = message.action.options.sendAs;
const auto messageFromId = sendAs
? sendAs->id
: anonymousPost
? 0
: session->userPeerId();
if (sendAs) {
sendFlags |= MTPmessages_SendMedia::Flag::f_send_as;
}
const auto messagePostAuthor = peer->isBroadcast()
? session->user()->name
: QString();
2019-07-17 14:34:39 +00:00
auto caption = TextWithEntities{
message.textWithTags.text,
2019-09-16 11:14:06 +00:00
TextUtilities::ConvertTextTagsToEntities(message.textWithTags.tags)
};
2019-07-17 14:34:39 +00:00
TextUtilities::Trim(caption);
2019-09-16 11:14:06 +00:00
auto sentEntities = EntitiesToMTP(
2020-06-08 08:03:45 +00:00
session,
2019-07-17 14:34:39 +00:00
caption.entities,
2019-09-16 11:14:06 +00:00
ConvertOption::SkipLocal);
2019-07-17 14:34:39 +00:00
if (!sentEntities.v.isEmpty()) {
sendFlags |= MTPmessages_SendMedia::Flag::f_entities;
}
const auto replyTo = message.action.replyTo;
2019-07-17 14:34:39 +00:00
const auto captionText = caption.text;
2019-08-12 16:33:36 +00:00
if (message.action.options.scheduled) {
2021-07-28 11:55:02 +00:00
flags |= MessageFlag::IsOrWasScheduled;
2019-08-12 16:33:36 +00:00
sendFlags |= MTPmessages_SendMedia::Flag::f_schedule_date;
}
2019-07-17 14:34:39 +00:00
session->data().registerMessageRandomId(randomId, newId);
2021-07-28 11:55:02 +00:00
const auto viaBotId = UserId();
2019-07-17 14:34:39 +00:00
history->addNewLocalMessage(
newId.msg,
flags,
2021-07-28 11:55:02 +00:00
viaBotId,
2019-07-17 14:34:39 +00:00
replyTo,
2019-08-12 16:33:36 +00:00
HistoryItem::NewMessageDate(message.action.options.scheduled),
2019-07-17 14:34:39 +00:00
messageFromId,
messagePostAuthor,
media,
caption,
2021-10-02 11:28:21 +00:00
HistoryMessageMarkupData());
2019-07-17 14:34:39 +00:00
auto performRequest = [=](const auto &repeatRequest) -> void {
auto &histories = history->owner().histories();
const auto requestType = Data::Histories::RequestType::Send;
histories.sendRequest(history, requestType, [=](Fn<void()> finish) {
const auto usedFileReference = media->fileReference();
history->sendRequestId = api->request(MTPmessages_SendMedia(
MTP_flags(sendFlags),
peer->input,
MTP_int(replyTo),
inputMedia(),
MTP_string(captionText),
MTP_long(randomId),
MTPReplyMarkup(),
sentEntities,
2021-11-05 12:05:11 +00:00
MTP_int(message.action.options.scheduled),
2021-11-09 15:24:13 +00:00
(sendAs ? sendAs->input : MTP_inputPeerEmpty())
)).done([=](const MTPUpdates &result) {
api->applyUpdates(result, randomId);
finish();
2021-03-12 12:48:00 +00:00
}).fail([=](const MTP::Error &error) {
if (error.code() == 400
&& error.type().startsWith(qstr("FILE_REFERENCE_"))) {
api->refreshFileReference(origin, [=](const auto &result) {
if (media->fileReference() != usedFileReference) {
repeatRequest(repeatRequest);
} else {
api->sendMessageFail(error, peer, randomId, newId);
}
});
} else {
api->sendMessageFail(error, peer, randomId, newId);
}
finish();
}).afterRequest(history->sendRequestId
).send();
return history->sendRequestId;
});
2019-07-17 14:34:39 +00:00
};
performRequest(performRequest);
2019-07-17 14:34:39 +00:00
api->finishForwarding(message.action);
2019-07-17 14:34:39 +00:00
}
} // namespace
void SendExistingDocument(
2021-11-18 07:03:03 +00:00
MessageToSend &&message,
not_null<DocumentData*> document) {
const auto inputMedia = [=] {
return MTP_inputMediaDocument(
MTP_flags(0),
document->mtpInput(),
2020-12-22 13:48:50 +00:00
MTPint(), // ttl_seconds
MTPstring()); // query
};
2019-07-17 14:34:39 +00:00
SendExistingMedia(
std::move(message),
2019-07-17 14:34:39 +00:00
document,
inputMedia,
document->stickerOrGifOrigin());
2019-07-17 14:34:39 +00:00
if (document->sticker()) {
document->owner().stickers().incrementSticker(document);
2019-07-17 14:34:39 +00:00
}
}
void SendExistingPhoto(
2021-11-18 07:03:03 +00:00
MessageToSend &&message,
not_null<PhotoData*> photo) {
const auto inputMedia = [=] {
return MTP_inputMediaPhoto(
MTP_flags(0),
photo->mtpInput(),
MTPint());
};
2019-07-17 14:34:39 +00:00
SendExistingMedia(
std::move(message),
2019-07-17 14:34:39 +00:00
photo,
inputMedia,
Data::FileOrigin());
2019-07-17 14:34:39 +00:00
}
2021-11-18 07:03:03 +00:00
bool SendDice(MessageToSend &message) {
const auto full = QStringView(message.textWithTags.text).trimmed();
2020-04-20 09:45:59 +00:00
auto length = 0;
if (!Ui::Emoji::Find(full.data(), full.data() + full.size(), &length)
|| length != full.size()) {
2020-03-06 12:12:03 +00:00
return false;
}
2020-04-20 09:45:59 +00:00
auto &account = message.action.history->session().account();
auto &config = account.appConfig();
static const auto hardcoded = std::vector<QString>{
2020-10-14 13:01:07 +00:00
Stickers::DicePacks::kDiceString,
Stickers::DicePacks::kDartString,
Stickers::DicePacks::kSlotString,
Stickers::DicePacks::kFballString,
Stickers::DicePacks::kFballString + QChar(0xFE0F),
Stickers::DicePacks::kBballString,
2020-04-20 09:45:59 +00:00
};
const auto list = config.get<std::vector<QString>>(
"emojies_send_dice",
hardcoded);
const auto emoji = full.toString();
2020-04-20 09:45:59 +00:00
if (!ranges::contains(list, emoji)) {
return false;
}
2020-03-06 12:12:03 +00:00
const auto history = message.action.history;
const auto peer = history->peer;
const auto session = &history->session();
const auto api = &session->api();
message.textWithTags = TextWithTags();
message.action.clearDraft = false;
message.action.generateLocal = true;
api->sendAction(message.action);
const auto newId = FullMsgId(
peerToChannel(peer->id),
session->data().nextLocalMessageId());
const auto randomId = base::RandomValue<uint64>();
2020-03-06 12:12:03 +00:00
auto &histories = history->owner().histories();
2021-07-28 11:55:02 +00:00
auto flags = NewMessageFlags(peer);
2020-03-06 12:12:03 +00:00
auto sendFlags = MTPmessages_SendMedia::Flags(0);
if (message.action.replyTo) {
2021-07-28 11:55:02 +00:00
flags |= MessageFlag::HasReplyInfo;
2020-03-06 12:12:03 +00:00
sendFlags |= MTPmessages_SendMedia::Flag::f_reply_to_msg_id;
}
const auto replyHeader = NewMessageReplyHeader(message.action);
2020-09-10 11:19:48 +00:00
const auto anonymousPost = peer->amAnonymous();
const auto silentPost = ShouldSendSilent(peer, message.action.options);
InnerFillMessagePostFlags(message.action.options, peer, flags);
2020-03-06 12:12:03 +00:00
if (silentPost) {
sendFlags |= MTPmessages_SendMedia::Flag::f_silent;
}
2021-11-09 15:24:13 +00:00
const auto sendAs = message.action.options.sendAs;
const auto messageFromId = sendAs
? sendAs->id
: anonymousPost
? 0
: session->userPeerId();
if (sendAs) {
sendFlags |= MTPmessages_SendMedia::Flag::f_send_as;
}
const auto messagePostAuthor = peer->isBroadcast()
? session->user()->name
: QString();
2020-03-06 12:12:03 +00:00
const auto replyTo = message.action.replyTo;
if (message.action.options.scheduled) {
2021-07-28 11:55:02 +00:00
flags |= MessageFlag::IsOrWasScheduled;
2020-03-06 12:12:03 +00:00
sendFlags |= MTPmessages_SendMedia::Flag::f_schedule_date;
}
session->data().registerMessageRandomId(randomId, newId);
2021-07-28 11:55:02 +00:00
const auto viaBotId = UserId();
history->addNewLocalMessage(
newId.msg,
flags,
viaBotId,
message.action.replyTo,
HistoryItem::NewMessageDate(message.action.options.scheduled),
messageFromId,
messagePostAuthor,
TextWithEntities(),
MTP_messageMediaDice(MTP_int(0), MTP_string(emoji)),
2021-10-02 11:28:21 +00:00
HistoryMessageMarkupData());
2020-03-06 12:12:03 +00:00
const auto requestType = Data::Histories::RequestType::Send;
histories.sendRequest(history, requestType, [=](Fn<void()> finish) {
history->sendRequestId = api->request(MTPmessages_SendMedia(
MTP_flags(sendFlags),
peer->input,
MTP_int(replyTo),
MTP_inputMediaDice(MTP_string(emoji)),
2020-03-06 12:12:03 +00:00
MTP_string(),
MTP_long(randomId),
MTPReplyMarkup(),
MTP_vector<MTPMessageEntity>(),
2021-11-05 12:05:11 +00:00
MTP_int(message.action.options.scheduled),
2021-11-09 15:24:13 +00:00
(sendAs ? sendAs->input : MTP_inputPeerEmpty())
2020-03-06 12:12:03 +00:00
)).done([=](const MTPUpdates &result) {
api->applyUpdates(result, randomId);
finish();
2021-03-12 12:48:00 +00:00
}).fail([=](const MTP::Error &error) {
2020-03-06 12:12:03 +00:00
api->sendMessageFail(error, peer, randomId, newId);
finish();
}).afterRequest(history->sendRequestId
).send();
return history->sendRequestId;
});
api->finishForwarding(message.action);
2020-03-06 12:12:03 +00:00
return true;
}
void FillMessagePostFlags(
2021-11-18 07:03:03 +00:00
const SendAction &action,
not_null<PeerData*> peer,
2021-07-28 11:55:02 +00:00
MessageFlags &flags) {
InnerFillMessagePostFlags(action.options, peer, flags);
}
2020-06-12 14:09:04 +00:00
void SendConfirmedFile(
not_null<Main::Session*> session,
const std::shared_ptr<FileLoadResult> &file) {
2021-07-28 11:55:02 +00:00
const auto isEditing = (file->type != SendMediaType::Audio)
&& (file->to.replaceMediaOf != 0);
2020-06-12 14:09:04 +00:00
const auto channelId = peerToChannel(file->to.peer);
const auto newId = FullMsgId(
channelId,
isEditing
? file->to.replaceMediaOf
: session->data().nextLocalMessageId());
const auto groupId = file->album ? file->album->groupId : uint64(0);
2020-06-12 14:09:04 +00:00
if (file->album) {
const auto proj = [](const SendingAlbum::Item &item) {
return item.taskId;
};
const auto it = ranges::find(file->album->items, file->taskId, proj);
Assert(it != file->album->items.end());
it->msgId = newId;
}
session->uploader().upload(newId, file);
const auto itemToEdit = isEditing
? session->data().message(newId)
: nullptr;
const auto history = session->data().history(file->to.peer);
const auto peer = history->peer;
2021-11-09 15:24:13 +00:00
auto action = SendAction(history, file->to.options);
2020-06-12 14:09:04 +00:00
action.clearDraft = false;
action.replyTo = file->to.replyTo;
action.generateLocal = true;
session->api().sendAction(action);
auto caption = TextWithEntities{
file->caption.text,
TextUtilities::ConvertTextTagsToEntities(file->caption.tags)
};
const auto prepareFlags = Ui::ItemTextOptions(
history,
session->user()).flags;
TextUtilities::PrepareForSending(caption, prepareFlags);
TextUtilities::Trim(caption);
2021-07-28 11:55:02 +00:00
auto flags = isEditing ? MessageFlags() : NewMessageFlags(peer);
2020-06-12 14:09:04 +00:00
if (file->to.replyTo) {
2021-07-28 11:55:02 +00:00
flags |= MessageFlag::HasReplyInfo;
2020-06-12 14:09:04 +00:00
}
const auto replyHeader = NewMessageReplyHeader(action);
2020-09-10 11:19:48 +00:00
const auto anonymousPost = peer->amAnonymous();
const auto silentPost = ShouldSendSilent(peer, file->to.options);
2021-07-28 11:55:02 +00:00
FillMessagePostFlags(action, peer, flags);
2020-06-12 14:09:04 +00:00
if (silentPost) {
2021-07-28 11:55:02 +00:00
flags |= MessageFlag::Silent;
2020-06-12 14:09:04 +00:00
}
if (file->to.options.scheduled) {
2021-07-28 11:55:02 +00:00
flags |= MessageFlag::IsOrWasScheduled;
// Scheduled messages have no the 'edited' badge.
2021-07-28 11:55:02 +00:00
flags |= MessageFlag::HideEdited;
2020-06-12 14:09:04 +00:00
}
if (file->type == SendMediaType::Audio) {
if (!peer->isChannel() || peer->isMegagroup()) {
flags |= MessageFlag::MediaIsUnread;
}
}
2020-06-12 14:09:04 +00:00
2021-11-09 15:24:13 +00:00
const auto messageFromId =
file->to.options.sendAs
? file->to.options.sendAs->id
: anonymousPost
? PeerId()
: session->userPeerId();
2020-09-10 11:19:48 +00:00
const auto messagePostAuthor = peer->isBroadcast()
2020-06-12 14:09:04 +00:00
? session->user()->name
: QString();
const auto media = MTPMessageMedia([&] {
2021-07-28 11:55:02 +00:00
if (file->type == SendMediaType::Photo) {
return MTP_messageMediaPhoto(
MTP_flags(MTPDmessageMediaPhoto::Flag::f_photo),
file->photo,
MTPint());
} else if (file->type == SendMediaType::File) {
return MTP_messageMediaDocument(
MTP_flags(MTPDmessageMediaDocument::Flag::f_document),
file->document,
MTPint());
} else if (file->type == SendMediaType::Audio) {
return MTP_messageMediaDocument(
MTP_flags(MTPDmessageMediaDocument::Flag::f_document),
file->document,
MTPint());
2020-06-12 14:09:04 +00:00
} else {
2021-07-28 11:55:02 +00:00
Unexpected("Type in sendFilesConfirmed.");
2020-06-12 14:09:04 +00:00
}
}());
2020-06-12 14:09:04 +00:00
2021-07-28 11:55:02 +00:00
if (itemToEdit) {
itemToEdit->savePreviousMedia();
auto edition = HistoryMessageEdition();
edition.isEditHide = (flags & MessageFlag::HideEdited);
edition.editDate = 0;
edition.views = 0;
edition.forwards = 0;
edition.ttl = 0;
edition.mtpMedia = &media;
edition.textWithEntities = caption;
edition.useSameMarkup = true;
edition.useSameReplies = true;
itemToEdit->applyEdition(std::move(edition));
2020-06-12 14:09:04 +00:00
} else {
2021-07-28 11:55:02 +00:00
const auto viaBotId = UserId();
history->addNewLocalMessage(
newId.msg,
flags,
viaBotId,
file->to.replyTo,
HistoryItem::NewMessageDate(file->to.options.scheduled),
messageFromId,
messagePostAuthor,
caption,
media,
2021-10-02 11:28:21 +00:00
HistoryMessageMarkupData(),
2021-07-28 11:55:02 +00:00
groupId);
2020-06-12 14:09:04 +00:00
}
if (isEditing) {
return;
}
session->data().sendHistoryChangeNotifications();
if (!itemToEdit) {
session->changes().historyUpdated(
history,
(action.options.scheduled
? Data::HistoryUpdate::Flag::ScheduledSent
: Data::HistoryUpdate::Flag::MessageSent));
}
2020-06-12 14:09:04 +00:00
}
2019-07-17 14:34:39 +00:00
} // namespace Api