vaegram 0.2.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::{Error, Result};
use crate::raw::{base, functions};
use crate::types::{EphemeralMessage, InputMedia, MessageText, PeerRef, ReplyMarkup};

#[must_use = "a request does nothing until it is awaited"]
/// Request built by the `edit_ephemeral_message_*` methods. Awaiting it returns the edited [`EphemeralMessage`].
pub struct EditEphemeralMessage<'a> {
    client: &'a Client,
    chat_id: PeerRef,
    receiver_user_id: PeerRef,
    ephemeral_message_id: i32,
    text: Option<MessageText>,
    media: Option<Box<InputMedia<'a>>>,
    parse_mode: Option<ParseMode>,
    invert_media: bool,
    reply_markup: Option<ReplyMarkup>,
}

impl Client {
    /// Replaces the text of an ephemeral message that `receiver_user_id` sees.
    ///
    /// Awaiting the request returns the edited [`EphemeralMessage`].
    pub fn edit_ephemeral_message_text(
        &self,
        chat_id: impl Into<PeerRef>,
        receiver_user_id: impl Into<PeerRef>,
        ephemeral_message_id: i32,
        text: impl Into<MessageText>,
    ) -> EditEphemeralMessage<'_> {
        EditEphemeralMessage::new(self, chat_id.into(), receiver_user_id.into(), ephemeral_message_id).text(text.into())
    }
}

impl<'a> EditEphemeralMessage<'a> {
    pub(crate) fn new(client: &'a Client, chat_id: PeerRef, receiver_user_id: PeerRef, id: i32) -> Self {
        EditEphemeralMessage {
            client,
            chat_id,
            receiver_user_id,
            ephemeral_message_id: id,
            text: None,
            media: None,
            parse_mode: None,
            invert_media: false,
            reply_markup: None,
        }
    }

    pub(crate) fn text(mut self, text: MessageText) -> Self {
        self.text = Some(text);
        self
    }

    pub(crate) fn media(mut self, media: InputMedia<'a>) -> Self {
        self.media = Some(Box::new(media));
        self
    }

    /// Shows the caption above the media instead of below it.
    pub fn show_caption_above_media(mut self) -> Self {
        self.invert_media = true;
        self
    }

    /// Attaches a reply markup to the edited message.
    pub fn reply_markup(mut self, markup: impl Into<ReplyMarkup>) -> Self {
        self.reply_markup = Some(markup.into());
        self
    }

    async fn request(
        self,
        peer: base::InputPeer,
        receiver_id: base::InputUser,
        message: Option<String>,
        entities: Option<Vec<base::MessageEntity>>,
        rich_message: Option<base::InputRichMessage>,
        media: Option<base::InputMedia>,
    ) -> Result<functions::ephemeral::EditMessage> {
        Ok(functions::ephemeral::EditMessage {
            invert_media: self.invert_media,
            welcome: false,
            peer: Some(peer),
            receiver_id,
            id: self.ephemeral_message_id,
            message,
            media,
            entities,
            reply_markup: ReplyMarkup::write_option(self.reply_markup.as_ref(), self.client).await?,
            rich_message,
        })
    }

    async fn send(mut self) -> Result<EphemeralMessage> {
        let client = self.client;
        let (text, mut media) = (self.text.take(), self.media.take());
        let (message, entities, rich_message) = match (text, &mut media) {
            (Some(_), Some(_)) => return Err(Error::InvalidArgument("edit either the text or the media, not both")),
            (Some(text), None) => text.write(client, self.parse_mode).await?,
            (None, Some(media)) => {
                self.invert_media |= media.show_caption_above_media;
                let (caption, entities) =
                    client.write_text(std::mem::take(&mut media.caption), media.parse_mode).await?;
                (Some(caption), (!entities.is_empty()).then_some(entities), None)
            }
            (None, None) => (None, None, None),
        };
        let peer = client.resolve(&self.chat_id).await?.1;
        let receiver_id = client.resolve_user(&self.receiver_user_id).await?;
        let media = match media {
            Some(media) => Some(client.input_media(&peer, &media, None, None).await?),
            None => None,
        };
        let request = self.request(peer, receiver_id, message, entities, rich_message, media).await?;
        let updates = client.invoke(&request).await?;
        EphemeralMessage::from_updates(client, updates)
    }
}

caption_setters!(EditEphemeralMessage);
into_future!(EditEphemeralMessage, EphemeralMessage);

#[cfg(test)]
mod tests {
    use super::EditEphemeralMessage;
    use crate::Client;
    use crate::errors::Error;
    use crate::raw::{Serializable, base, functions, types};
    use crate::types::messages_and_media::Source;
    use crate::types::{FileSource, InputMedia, InputRichMessage};

    async fn request(edit: EditEphemeralMessage<'_>) -> functions::ephemeral::EditMessage {
        let peer = base::InputPeer::InputPeerChat(types::InputPeerChat { chat_id: 1 });
        edit.request(peer, base::InputUser::InputUserSelf, None, None, None, None).await.unwrap()
    }

    #[tokio::test]
    async fn edits_markup_without_touching_text() {
        let client = Client::offline();
        let edit = client.edit_ephemeral_message_reply_markup(-1, 1000, 3);
        assert!(edit.text.is_none());
        let request = request(edit).await;
        assert_eq!((request.message, request.reply_markup, request.invert_media), (None, None, false));
    }

    #[tokio::test]
    async fn refuses_text_and_media_together() {
        let (client, mut sent) = Client::recording();
        let edit = client.edit_ephemeral_message_media(-5, "me", 3, InputMedia::photo("cat.jpg")).text("x".into());
        assert!(matches!(edit.await, Err(Error::InvalidArgument(_))));
        assert!(sent.try_recv().is_err());
    }

    #[tokio::test]
    async fn rich_text_goes_to_rich_message() {
        let (client, mut rx) = Client::recording();
        let edit = client.edit_ephemeral_message_text("me", "me", 3, InputRichMessage::html("<b>hi</b>"));
        assert!(edit.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 & 0b11, flags & 1 << 4 != 0), (0, true));
        let html = types::InputRichMessageHTML { rtl: false, noautolink: false, html: "<b>hi</b>".into(), files: None };
        assert!(body.ends_with(&base::InputRichMessage::InputRichMessageHTML(Box::new(html)).to_bytes()));
    }

    #[tokio::test]
    async fn media_edits_carry_the_caption_of_the_media() {
        const PHOTO: &str = "AgACAgIAAxkBAAIENGfeY4AfRquwTL2LpDrzqvFMVNt_AAIG9DEbXX3wSq3oI7t_PqQGAQADAgADbQADNgQ";
        let (client, mut sent) = Client::recording();
        let photo = FileSource::file_id(PHOTO).unwrap();
        let media = InputMedia::photo(photo.clone()).caption("<b>new</b>").html().show_caption_above_media();
        let _ = client.edit_ephemeral_message_media(-5, "me", 3, media).await;

        let Source::Stored(stored) = photo.0 else { panic!("not a stored file") };
        let bold = types::MessageEntityBold { offset: 0, length: 3 };
        let request = functions::ephemeral::EditMessage {
            invert_media: true,
            welcome: false,
            peer: Some(base::InputPeer::InputPeerChat(types::InputPeerChat { chat_id: 5 })),
            receiver_id: base::InputUser::InputUserSelf,
            id: 3,
            message: Some("new".into()),
            media: Some(stored),
            entities: Some(vec![base::MessageEntity::MessageEntityBold(bold)]),
            reply_markup: None,
            rich_message: None,
        };
        assert_eq!(sent.try_recv().expect("no request sent"), request.to_bytes());
    }
}