Struct InlineQueryResultArticle 

pub struct InlineQueryResultArticle {
    pub id: String,
    pub title: String,
    pub input_message_content: InputMessageContent,
    pub reply_markup: Option<InlineKeyboardMarkup>,
    pub url: Option<Url>,
    pub description: Option<String>,
    pub thumbnail_url: Option<Url>,
    pub thumbnail_width: Option<u32>,
    pub thumbnail_height: Option<u32>,
}

Represents a link to an article or web page.

The official docs.

Fields

id: String

Unique identifier for this result, 1-64 Bytes.

title: String

Title of the result.

input_message_content: InputMessageContent

Content of the message to be sent.

reply_markup: Option<InlineKeyboardMarkup>

Inline keyboard attached to the message.

url: Option<Url>

URL of the result.

description: Option<String>

Short description of the result.

thumbnail_url: Option<Url>

Url of the thumbnail for the result.

thumbnail_width: Option<u32>

Thumbnail width.

thumbnail_height: Option<u32>

Thumbnail height.

Implementations

impl InlineQueryResultArticle

pub fn new<S1, S2>( id: S1, title: S2, input_message_content: InputMessageContent, ) -> InlineQueryResultArticle

where S1: Into<String>, S2: Into<String>,

Examples found in repository

examples/buttons.rs (lines 93-97)

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 18-30)

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 id<S>(self, val: S) -> InlineQueryResultArticle

where S: Into<String>,

pub fn title<S>(self, val: S) -> InlineQueryResultArticle

where S: Into<String>,

pub fn input_message_content( self, val: InputMessageContent, ) -> InlineQueryResultArticle

pub fn reply_markup(self, val: InlineKeyboardMarkup) -> InlineQueryResultArticle

Examples found in repository

examples/buttons.rs (line 98)

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(())
}

pub fn url(self, val: Url) -> InlineQueryResultArticle

Examples found in repository

examples/inline.rs (line 45)

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 description<S>(self, val: S) -> InlineQueryResultArticle

where S: Into<String>,

Examples found in repository

examples/inline.rs (line 43)

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 thumbnail_url(self, val: Url) -> InlineQueryResultArticle

Examples found in repository

examples/inline.rs (line 44)

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 thumbnail_width(self, val: u32) -> InlineQueryResultArticle

pub fn thumbnail_height(self, val: u32) -> InlineQueryResultArticle

Trait Implementations

impl Clone for InlineQueryResultArticle

fn clone(&self) -> InlineQueryResultArticle

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InlineQueryResultArticle

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for InlineQueryResultArticle

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<InlineQueryResultArticle> for InlineQueryResult

fn from(value: InlineQueryResultArticle) -> InlineQueryResult

Converts to this type from the input type.

impl PartialEq for InlineQueryResultArticle

fn eq(&self, other: &InlineQueryResultArticle) -> 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 InlineQueryResultArticle

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 InlineQueryResultArticle