feat(cobalt): show video after sending inline query result to chat (also removes thumbnail placeholder)

Author: nixxoq

src/bot/dispatcher.rs

@@ -31,6 +31,7 @@ use teloxide::{
     update_listeners::Polling,
     utils::{command::BotCommands, html},
 };
+use crate::bot::inlines::cobalter::handle_inline_video;
 
 async fn root_handler(
     update: Update,
@@ -78,7 +79,8 @@ async fn run_bot(config: Arc<Config>) -> Result<(), MyError> {
         )
         .branch(Update::filter_callback_query().endpoint(callback_query_handlers))
         .branch(Update::filter_my_chat_member().endpoint(handle_bot_added))
-        .branch(Update::filter_inline_query().branch(inline_query_handler()));
+        .branch(Update::filter_inline_query().branch(inline_query_handler()))
+        .branch(Update::filter_chosen_inline_result().endpoint(handle_inline_video));
 
     let me = bot.get_me().await?;
     info!("Bot name: {:?}", me.username());

src/bot/inlines/cobalter.rs

@@ -18,9 +18,10 @@ use teloxide::{
     prelude::*,
     types::{
         InlineQuery, InlineQueryResult, InlineQueryResultArticle, InlineQueryResultPhoto,
-        InlineQueryResultVideo, InputMessageContent, InputMessageContentText,
+        InputMessageContent, InputMessageContentText, InputFile, InputMedia, InputMediaVideo
     },
 };
+use url::Url;
 
 static URL_REGEX: Lazy<Regex> =
     Lazy::new(|| Regex::new(r"^(https?)://[^\s/$.?#].[^\s]*$").unwrap());
@@ -48,18 +49,18 @@ fn build_results_from_media(
     user_id: u64,
 ) -> Vec<InlineQueryResult> {
     match media {
-        DownloadResult::Video(video_url) => {
-            if let Ok(url) = video_url.parse() {
+        DownloadResult::Video { url, .. } => {
+            if let Ok(_url) = url.parse::<Url>() {
                 let url_kb = make_single_url_keyboard(original_url);
-
-                let result = InlineQueryResultVideo::new(
+                let result = InlineQueryResultArticle::new(
                     format!("cobalt_video:{}", url_hash),
-                    url,
-                    "video/mp4".parse().unwrap(),
-                    "https://i.imgur.com/D0A9Gxh.png".parse().unwrap(), /* preview */
-                    "Скачать видео".to_string(),
+                    "Скачать видео",
+                    InputMessageContent::Text(InputMessageContentText::new(
+                        "Нажмите, чтобы отправить видео",
+                    )),
                 )
                 .reply_markup(url_kb);
+
                 vec![result.into()]
             } else {
                 vec![
@@ -164,3 +165,48 @@ pub async fn handle_cobalt_inline(
     bot.answer_inline_query(q.id, results).cache_time(0).await?;
     Ok(())
 }
+
+pub async fn handle_inline_video(
+    bot: Bot,
+    chosen: ChosenInlineResult,
+    config: Arc<Config>,
+) -> Result<(), MyError> {
+    let Some(inline_message_id) = chosen.inline_message_id else {
+        return Ok(());
+    };
+
+    let Some(url_hash) = chosen.result_id.strip_prefix("cobalt_video:") else {
+        return Ok(());
+    };
+
+    bot.edit_message_text_inline(&inline_message_id, "⏳ Загружаю видео...")
+        .await?;
+
+    let redis = config.get_redis_client();
+    let cache_key = format!("cobalt_cache:{}", url_hash);
+
+    match redis.get::<DownloadResult>(&cache_key).await? {
+        Some(DownloadResult::Video { url, original_url }) => {
+            let media = InputMedia::Video(InputMediaVideo::new(InputFile::url(url.parse()?)));
+            let url_kb = make_single_url_keyboard(&original_url);
+
+            if let Err(_e) = bot
+                .edit_message_media_inline(&inline_message_id, media)
+                .reply_markup(url_kb)
+                .await
+            {
+                bot.edit_message_text_inline(
+                    inline_message_id,
+                    "❌ Ошибка: не удалось отправить видео.",
+                )
+                .await?;
+            }
+        }
+        _ => {
+            bot.edit_message_text_inline(inline_message_id, "❌ Ошибка: видео не найдено в кэше.")
+                .await?;
+        }
+    }
+
+    Ok(())
+}

src/core/services/cobalt.rs

@@ -35,7 +35,10 @@ impl VideoQuality {
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub enum DownloadResult {
-    Video(String),
+    Video {
+        url: String,
+        original_url: String,
+    },
     Photos {
         urls: Vec<String>,
         original_url: String,
@@ -77,26 +80,43 @@ pub async fn resolve_download_url(
                 }));
             }
             if let Some(video_item) = picker.iter().find(|item| item.kind == "video") {
-                return Ok(Some(DownloadResult::Video(video_item.url.clone())));
+                return Ok(Some(DownloadResult::Video {
+                    url: video_item.url.clone(),
+                    original_url: url.to_string(),
+                }));
             }
             Ok(None)
         }
-        DownloadResponse::Tunnel { url, filename }
-        | DownloadResponse::Redirect { url, filename } => {
+        DownloadResponse::Tunnel {
+            url: c_url,
+            filename,
+        }
+        | DownloadResponse::Redirect {
+            url: c_url,
+            filename,
+        } => {
             const PHOTO_EXTENSIONS: &[&str] = &[".jpg", ".jpeg", ".png", ".gif", ".webp"];
             let is_photo = PHOTO_EXTENSIONS
                 .iter()
                 .any(|ext| filename.to_lowercase().ends_with(ext));
 
             if is_photo {
                 Ok(Some(DownloadResult::Photos {
-                    urls: vec![url.clone()],
-                    original_url: url,
+                    urls: vec![c_url.clone()],
+                    original_url: url.to_string(),
                 }))
             } else {
-                Ok(Some(DownloadResult::Video(url)))
+                Ok(Some(DownloadResult::Video {
+                    url: c_url,
+                    original_url: url.to_string(),
+                }))
             }
         }
-        _ => Ok(response.get_download_url().map(DownloadResult::Video)),
+        _ => Ok(response
+            .get_download_url()
+            .map(|c_url| DownloadResult::Video {
+                url: c_url,
+                original_url: url.to_string(),
+            })),
     }
 }