vaegram 0.3.0

Telegram MTProto client library for users and bots
Documentation
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"]
/// Request built by [`Client::edit_message_text`]. Awaiting it returns the edited [`Message`].
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 {
    /// Replaces the text of `message_id` and returns the edited [`Message`].
    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<'_> {
    /// Attaches an inline keyboard to the message.
    pub fn reply_markup(mut self, markup: impl Into<ReplyMarkup>) -> Self {
        self.reply_markup = Some(markup.into());
        self
    }

    /// Edits on behalf of this business connection.
    pub fn business_connection_id(mut self, id: impl Into<String>) -> Self {
        self.business_connection_id = Some(id.into());
        self
    }

    /// For captions of photos, videos and animations.
    pub fn show_caption_above_media(mut self) -> Self {
        self.show_caption_above_media = true;
        self
    }

    /// Edits a scheduled message and moves it to this Unix time.
    pub fn schedule_date(mut self, date: i32) -> Self {
        self.schedule_date = Some(date);
        self
    }

    /// Which link to preview, how, and whether to show it above the text. Replaces the client default.
    pub fn link_preview_options(mut self, options: LinkPreviewOptions) -> Self {
        self.link_preview_options = Some(options);
        self
    }

    /// For caption edits: the client's link preview default is meant for text, not for moving captions.
    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());
        // media is flag bit 14, invert_media bit 16, no_webpage bit 1.
        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());
    }
}