use super::send_options::caption_setters;
use crate::Client;
use crate::enums::ParseMode;
use crate::errors::Result;
use crate::raw::{base, functions};
use crate::types::{LinkPreviewOptions, Message, MessageText, PeerRef, ReplyMarkup};
#[must_use = "a request does nothing until it is awaited"]
pub struct EditMessageText<'a> {
client: &'a Client,
chat_id: PeerRef,
message_id: i32,
text: MessageText,
parse_mode: Option<ParseMode>,
show_caption_above_media: bool,
reply_markup: Option<ReplyMarkup>,
business_connection_id: Option<String>,
schedule_date: Option<i32>,
link_preview_options: Option<LinkPreviewOptions>,
apply_client_default: bool,
}
impl Client {
pub fn edit_message_text(
&self,
chat_id: impl Into<PeerRef>,
message_id: i32,
text: impl Into<MessageText>,
) -> EditMessageText<'_> {
EditMessageText {
client: self,
chat_id: chat_id.into(),
message_id,
text: text.into(),
parse_mode: None,
show_caption_above_media: false,
reply_markup: None,
business_connection_id: None,
schedule_date: None,
link_preview_options: None,
apply_client_default: true,
}
}
}
impl EditMessageText<'_> {
pub fn reply_markup(mut self, markup: impl Into<ReplyMarkup>) -> Self {
self.reply_markup = Some(markup.into());
self
}
pub fn business_connection_id(mut self, id: impl Into<String>) -> Self {
self.business_connection_id = Some(id.into());
self
}
pub fn show_caption_above_media(mut self) -> Self {
self.show_caption_above_media = true;
self
}
pub fn schedule_date(mut self, date: i32) -> Self {
self.schedule_date = Some(date);
self
}
pub fn link_preview_options(mut self, options: LinkPreviewOptions) -> Self {
self.link_preview_options = Some(options);
self
}
pub(crate) fn without_client_default(mut self) -> Self {
self.apply_client_default = false;
self
}
async fn send(self) -> Result<Message> {
let client = self.client;
let preview = if self.apply_client_default {
client.link_preview(self.link_preview_options.as_ref())
} else {
self.link_preview_options.clone()
}
.map(|o| o.resolve())
.unwrap_or_default();
let no_webpage = preview.no_webpage;
let (chat_id, peer) = client.resolve(&self.chat_id).await?;
let (message, entities, rich_message) = self.text.write(client, self.parse_mode).await?;
let request = functions::messages::EditMessage {
no_webpage,
invert_media: self.show_caption_above_media || preview.invert_media,
media: if no_webpage { None } else { preview.media },
message,
reply_markup: ReplyMarkup::write_option(self.reply_markup.as_ref(), self.client).await?,
entities,
schedule_date: self.schedule_date,
rich_message,
..edit_request(peer, self.message_id)
};
let (updates, request) = client.invoke_business(self.business_connection_id.as_deref(), request).await?;
Message::from_updates(
client,
updates,
Message::request(chat_id, request.message.unwrap_or_default(), request.entities),
)
}
}
pub(super) fn edit_request(peer: base::InputPeer, id: i32) -> functions::messages::EditMessage {
functions::messages::EditMessage {
no_webpage: false,
invert_media: false,
peer,
id,
message: None,
media: None,
reply_markup: None,
entities: None,
schedule_date: None,
schedule_repeat_period: None,
quick_reply_shortcut_id: None,
rich_message: None,
}
}
caption_setters!(EditMessageText);
into_future!(EditMessageText, Message);
impl crate::methods::OnBehalf for EditMessageText<'_> {
fn business_connection(&mut self) -> &mut Option<String> {
&mut self.business_connection_id
}
}
#[cfg(test)]
mod tests {
use crate::Client;
use crate::raw::{Serializable, base, types};
use crate::types::{InputRichMessage, LinkPreviewOptions};
#[tokio::test]
async fn a_client_default_leaves_caption_edits_alone() {
let default = LinkPreviewOptions::new().show_above_text(true);
let (client, mut rx) = Client::recording();
client.set_link_preview_options(Some(default));
let _ = client.edit_message_caption("me", 5, "cap").await;
let _ = client.edit_message_text("me", 5, "text").await;
let flags = |body: Vec<u8>| u32::from_le_bytes(body[4..8].try_into().unwrap()) >> 16 & 1;
assert_eq!((flags(rx.try_recv().unwrap()), flags(rx.try_recv().unwrap())), (0, 1));
}
#[tokio::test]
async fn edit_text_with_url_sets_media() {
let (client, mut rx) = Client::recording();
let options = LinkPreviewOptions::new().url("https://a.b").show_above_text(true);
let _ = client.edit_message_text("me", 5, "hi").link_preview_options(options).await;
let body = rx.try_recv().unwrap();
let flags = u32::from_le_bytes(body[4..8].try_into().unwrap());
assert_eq!((flags >> 14 & 1, flags >> 16 & 1, flags >> 1 & 1), (1, 1, 0));
let disabled = LinkPreviewOptions::new().url("https://a.b").is_disabled(true);
let _ = client.edit_message_text("me", 5, "hi").link_preview_options(disabled).await;
let flags = u32::from_le_bytes(rx.try_recv().unwrap()[4..8].try_into().unwrap());
assert_eq!((flags >> 14 & 1, flags >> 1 & 1), (0, 1));
}
#[tokio::test]
async fn rich_message_replaces_text() {
let (client, mut rx) = Client::recording();
assert!(client.edit_message_text("me", 5, InputRichMessage::markdown("_x_")).await.is_err());
let body = rx.try_recv().expect("no request sent");
let flags = u32::from_le_bytes(body[4..8].try_into().unwrap());
assert_eq!((flags & 1 << 11, flags & 1 << 3, flags & 1 << 23 != 0), (0, 0, true));
let markdown =
types::InputRichMessageMarkdown { rtl: false, noautolink: false, markdown: "_x_".into(), files: None };
assert!(body.ends_with(&base::InputRichMessage::InputRichMessageMarkdown(Box::new(markdown)).to_bytes()));
assert!(client.edit_message_text("me", 5, "hi").await.is_err());
let flags = u32::from_le_bytes(rx.try_recv().unwrap()[4..8].try_into().unwrap());
assert_eq!((flags & 1 << 11 != 0, flags & 1 << 23), (true, 0));
}
#[tokio::test]
async fn business_edits_go_through_the_connection() {
let (client, mut rx) = Client::recording();
client.0.caches.know_business("c", 7, 2);
assert!(client.edit_message_text("me", 5, "hi").business_connection_id("c").await.is_err());
let body = rx.try_recv().expect("no request sent");
assert_eq!(body[..4], 0xdd289f8e_u32.to_le_bytes());
}
}