Struct InputMessageContentText 

pub struct InputMessageContentText {
    pub message_text: String,
    pub parse_mode: Option<ParseMode>,
    pub entities: Option<Vec<MessageEntity>>,
    pub link_preview_options: Option<LinkPreviewOptions>,
}

Represents the content of a text message to be sent as the result of an inline query.

Fields

message_text: String

Text of the message to be sent, 1-4096 characters.

parse_mode: Option<ParseMode>

Send Markdown or HTML, if you want Telegram apps to show bold, italic, fixed-width text or inline URLs in the media caption.

entities: Option<Vec<MessageEntity>>

List of special entities that appear in message text, which can be specified instead of parse_mode.

link_preview_options: Option<LinkPreviewOptions>

Link preview generation options for the message

Implementations

impl InputMessageContentText

pub fn new<S>(message_text: S) -> InputMessageContentText

where S: Into<String>,

Examples found in repository

examples/buttons.rs (line 96)

async fn inline_query_handler(
    bot: Bot,
    q: InlineQuery,
) -> Result<(), Box<dyn Error + Send + Sync>> {
    let choose_debian_version = InlineQueryResultArticle::new(
        "0",
        "Chose debian version",
        InputMessageContent::Text(InputMessageContentText::new("Debian versions:")),
    )
    .reply_markup(make_keyboard());

    bot.answer_inline_query(q.id, vec![choose_debian_version.into()]).await?;

    Ok(())
}

examples/inline.rs (lines 26-29)

async fn main() {
    pretty_env_logger::init();
    log::info!("Starting inline bot...");

    let bot = Bot::from_env();

    let handler = Update::filter_inline_query().branch(dptree::endpoint(
        |bot: Bot, q: InlineQuery| async move {
            // First, create your actual response
            let google_search = InlineQueryResultArticle::new(
                // Each item needs a unique ID, as well as the response container for the
                // items. These can be whatever, as long as they don't
                // conflict.
                "01".to_string(),
                // What the user will actually see
                "Google Search",
                // What message will be sent when clicked/tapped
                InputMessageContent::Text(InputMessageContentText::new(format!(
                    "https://www.google.com/search?q={}",
                    q.query,
                ))),
            );
            // While constructing them from the struct itself is possible, it is preferred
            // to use the builder pattern if you wish to add more
            // information to your result. Please refer to the documentation
            // for more detailed information about each field. https://docs.rs/teloxide/latest/teloxide/types/struct.InlineQueryResultArticle.html
            let ddg_search = InlineQueryResultArticle::new(
                "02".to_string(),
                "DuckDuckGo Search".to_string(),
                InputMessageContent::Text(InputMessageContentText::new(format!(
                    "https://duckduckgo.com/?q={}",
                    q.query
                ))),
            )
            .description("DuckDuckGo Search")
            .thumbnail_url("https://duckduckgo.com/assets/logo_header.v108.png".parse().unwrap())
            .url("https://duckduckgo.com/about".parse().unwrap()); // Note: This is the url that will open if they click the thumbnail

            let results = vec![
                InlineQueryResult::Article(google_search),
                InlineQueryResult::Article(ddg_search),
            ];

            // Send it off! One thing to note -- the ID we use here must be of the query
            // we're responding to.
            let response = bot.answer_inline_query(q.id.clone(), results).send().await;
            if let Err(err) = response {
                log::error!("Error in handler: {err:?}");
            }
            respond(())
        },
    ));

    Dispatcher::builder(bot, handler).enable_ctrlc_handler().build().dispatch().await;
}

pub fn message_text<S>(self, val: S) -> InputMessageContentText

where S: Into<String>,

pub fn parse_mode(self, val: ParseMode) -> InputMessageContentText

pub fn entities<C>(self, val: C) -> InputMessageContentText

where C: IntoIterator<Item = MessageEntity>,

pub fn link_preview_options( self, val: LinkPreviewOptions, ) -> InputMessageContentText

Trait Implementations

impl Clone for InputMessageContentText

fn clone(&self) -> InputMessageContentText

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for InputMessageContentText

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for InputMessageContentText

fn deserialize<__D>( __deserializer: __D, ) -> Result<InputMessageContentText, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for InputMessageContentText

fn eq(&self, other: &InputMessageContentText) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for InputMessageContentText

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for InputMessageContentText