Bump version to 0.2.2, add inline command for listing unviewed videos

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "doggy-watch"
 authors = ["Shiroyashik <shiroyashik@shsr.ru>"]
-version = "0.2.0"
+version = "0.2.2"
 edition = "2021"
 publish = false
 
@@ -26,6 +26,7 @@ tracing-panic = "0.1"
 lazy_static = "1.5"
 indexmap = "2.7"
 dashmap = "6.1"
+url = "2.5"
 
 # https://github.com/teloxide/teloxide/issues/1154
 # [profile.dev]

Dockerfile

@@ -1,6 +1,6 @@
 ## Chef
 # FROM clux/muslrust:stable AS chef
-FROM rust:1.84.0-alpine3.20 AS chef
+FROM rust:alpine AS chef
 USER root
 RUN apk add --no-cache musl-dev libressl-dev
 RUN cargo install cargo-chef

README.md

@@ -35,6 +35,10 @@ ID канала для проверки подписки.
 `trace, debug, info, warn, error`
 Также можно указать отдельный уровень логирования для отдельных целей.
 
+`TELEGRAM_API_URL=<url>`
+
+Сторонний Telegram Bot API сервер (необязательно).
+
 ### Только для Docker
 
 `TZ=<TZ_identifier>`

migration/src/m20241211_182453_create_tables.rs

@@ -108,22 +108,22 @@ impl MigrationTrait for Migration {
     }
 
     async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
-        // Videos
+        // Actions
         manager
-            .drop_table(Table::drop().table(Videos::Table).to_owned())
+            .drop_table(Table::drop().table(Actions::Table).to_owned())
             .await?;
         // Requests
         manager
             .drop_table(Table::drop().table(Requests::Table).to_owned())
             .await?;
-        // Actions
-        manager
-            .drop_table(Table::drop().table(Actions::Table).to_owned())
-            .await?;
         // Archived
         manager
             .drop_table(Table::drop().table(Archived::Table).to_owned())
             .await?;
+        // Videos
+        manager
+            .drop_table(Table::drop().table(Videos::Table).to_owned())
+            .await?;
         // Moderators
         manager
             .drop_table(Table::drop().table(Moderators::Table).to_owned())

src/handle/add.rs

@@ -10,10 +10,17 @@ use crate::{check_subscription, markup, notify, AppState, DialogueState, MyDialo
 pub async fn message(bot: Bot, msg: Message, dialogue: MyDialogue) -> anyhow::Result<()> {
     use youtube::*;
     if let Some(text) = msg.clone().text() {
-        if let Some(user) = check_subscription(&bot, &msg.from.ok_or(anyhow::anyhow!("Message not from user!"))?.id).await {
+        if let Some(user) = check_subscription(&bot, &msg.clone().from.ok_or(anyhow::anyhow!("Message not from user!"))?.id).await {
             // Get ready!
             if let Some(ytid) = extract_youtube_video_id(text) {
-                let meta = get_video_metadata(&ytid).await?;
+                let meta = match get_video_metadata(&ytid).await {
+                    Ok(meta) => meta,
+                    Err(err) => {
+                        tracing::error!("Caused an exception in get_video_metadata due: {err:?}");
+                        bot.send_message(msg.chat.id, "Ошибка при получении метаданных видео!").await?;
+                        return Ok(());
+                    },
+                };
                 // Post
                 bot.send_message(msg.chat.id, format!(
                     "Вы уверены что хотите добавить <b>{}</b>",
@@ -21,7 +28,8 @@ pub async fn message(bot: Bot, msg: Message, dialogue: MyDialogue) -> anyhow::Re
                 )).parse_mode(ParseMode::Html).reply_markup(markup::inline_yes_or_no()).await?;
                 dialogue.update(DialogueState::AcceptVideo { ytid, uid: user.id.0, title: meta.title }).await?;
             } else {
-                bot.send_message(msg.chat.id, "Это не похоже на YouTube видео... Долбоёб").await?; 
+                tracing::debug!("Not a YouTube video: {:?}", msg);
+                bot.send_message(msg.chat.id, "Это не похоже на YouTube видео... Долбоёб").await?;
             }
         } else {
             let link = if let Some(hash) = CHANNEL_INVITE_HASH.as_ref() {

src/handle/list.rs

@@ -1,84 +1,161 @@
 use std::sync::Arc;
 
 use indexmap::IndexMap;
-use teloxide::{prelude::*, types::{LinkPreviewOptions, ParseMode}};
+use teloxide::{prelude::*, types::{InlineKeyboardButton, InlineKeyboardMarkup, LinkPreviewOptions, ParseMode}};
 use sea_orm::{prelude::*, Order, QueryOrder};
 
 use database::*;
 
 use crate::AppState;
 
+struct Video {
+    id: i32,
+    title: String,
+    url: String,
+    contributors: u64,
+    status: String,
+}
+
 pub async fn command(bot: Bot, msg: Message, state: Arc<AppState>) -> anyhow::Result<()> {
-    struct Video {
-        id: i32,
-        title: String,
-        url: String,
-        contributors: u64,
-        status: String,
-    }
     let videos: Vec<(requests::Model, Option<videos::Model>)> = requests::Entity::find()
         .find_also_related(videos::Entity).filter(videos::Column::Banned.eq(false)).all(&state.db).await?;
-    // let videos_len = videos.len();
-    if !videos.is_empty() {
-        let mut by_date: IndexMap<Date, Vec<Video>> = IndexMap::new();
-        for (request, video) in videos {
-            let video = video.unwrap();
-            let creator = if let Some(c) = request.find_related(actions::Entity).order_by(actions::Column::Id, Order::Asc).one(&state.db).await? {
-                c
+
+    let result = generate_list(videos, &state).await;
+    match result {
+        Ok(list) => {
+            let result = if let Some(list) = list {
+                list
             } else {
-                let data = format!("Can't find creator for {request:?}");
-                bot.send_message(msg.chat.id, data.clone()).await?;
-                anyhow::bail!(data);
+                "Нет видео для просмотра :(".to_string()
             };
 
-            let contributors = request.find_related(actions::Entity).count(&state.db).await?;
-            let date = creator.created_at.date();
-            let url = format!("{}{}", youtube::DEFAULT_YT, video.ytid);
+            let keyboard: Vec<Vec<InlineKeyboardButton>> = vec![
+                vec![InlineKeyboardButton::callback("Непросмотренные", "list_unviewed")],
+            ];
 
-            let viewed_times = archived::Entity::find().filter(archived::Column::Ytid.eq(video.ytid.clone())).filter(archived::Column::ViewedAt.is_not_null()).count(&state.db).await?;
-            let archived_times = archived::Entity::find().filter(archived::Column::Ytid.eq(video.ytid)).count(&state.db).await?;
-
-            let mut status = String::new();
-            status.push(if request.viewed_at.is_some() {
-                '👀'
-            } else if viewed_times != 0 {
-                '⭐'
-            } else if archived_times != 0 {
-                '📁'
-            } else {
-                '🆕'
-            });
-
-            if let Some(entry) = by_date.get_mut(&date) {
-                entry.push(Video { id: request.id, title: video.title, url, contributors, status });
-            } else {
-                by_date.insert(date, vec![Video { id: request.id, title: video.title, url, contributors, status }]);
-            };
-        }
-        by_date.sort_unstable_by(|a, _, c, _| c.cmp(a));
-        let mut result = String::new();
-        for (date, mut videos) in by_date {
-            if result.is_empty() {
-                result.push_str(&format!("[{}]", date.format("%d.%m")));
-            } else {
-                result.push_str(&format!("\n[{}]", date.format("%d.%m")));
-            }
-            // result.push_str(&format!(" {}", videos.len()));
-            videos.sort_unstable_by(|a, b| a.contributors.cmp(&b.contributors));
-            for video in videos {
-                let contributors = if video.contributors != 1 {
-                    format!("(🙍‍♂️{}) ", video.contributors)
-                } else {
-                    String::new()
-                };
-                result.push_str(&format!("\n{}/{} <a href=\"{}\">📺YT</a> {}<b>{}</b>", video.status, video.id, video.url, contributors, video.title));
-                // result.push_str(&format!("\n<a href=\"tg://resolve?domain={}&start=info%20{}\">{}.</a> <b>{}</b> <a href=\"{DEFAULT_YT}{}\">YT</a> ({})", me.username.clone().unwrap(), video.id, video.id, video.title, video.url, video.contributors));
-            }
-        }
-        // result.push_str(&format!("\nВсего: {}", videos_len));
-        bot.send_message(msg.chat.id, result).parse_mode(ParseMode::Html).link_preview_options(LinkPreviewOptions { is_disabled: true, url: None, prefer_small_media: false, prefer_large_media: false, show_above_text: false  }).await?;
-    } else {
-        bot.send_message(msg.chat.id, "Нет видео для просмотра :(").await?;
+            bot.send_message(msg.chat.id, result).parse_mode(ParseMode::Html)
+                .link_preview_options(LinkPreviewOptions { 
+                    is_disabled: true,
+                    url: None,
+                    prefer_small_media: false,
+                    prefer_large_media: false,
+                    show_above_text: false
+                }).reply_markup(InlineKeyboardMarkup::new(keyboard)).await?;
+        },
+        Err(e) => {
+            tracing::error!("{:?}", e);
+            bot.send_message(msg.chat.id, "Произошла ошибка!").await?;
+        },
     }
     Ok(())
+}
+
+pub async fn inline(state: Arc<AppState>, bot: Bot, q: CallbackQuery) -> anyhow::Result<()> {
+    bot.answer_callback_query(&q.id).await?;
+    let videos: Vec<(requests::Model, Option<videos::Model>)> = requests::Entity::find()
+        .find_also_related(videos::Entity).filter(videos::Column::Banned.eq(false)).filter(requests::Column::ViewedAt.is_null()).all(&state.db).await?;
+    let result = generate_list(videos, &state).await;
+    match result {
+        Ok(list) => {
+            let result = if let Some(list) = list {
+                list
+            } else {
+                "Нет видео для просмотра :(".to_string()
+            };
+
+            let keyboard: Vec<Vec<InlineKeyboardButton>> = vec![
+                vec![InlineKeyboardButton::callback("Обновить", "list_unviewed")],
+            ];
+
+            if let Some(message) = q.regular_message() {
+                bot.edit_message_text(message.chat.id, message.id, result).parse_mode(ParseMode::Html)
+                    .link_preview_options(LinkPreviewOptions {
+                        is_disabled: true,
+                        url: None,
+                        prefer_small_media: false,
+                        prefer_large_media: false,
+                        show_above_text: false
+                    }).reply_markup(InlineKeyboardMarkup::new(keyboard)).await?;
+            } else if let Some(message_id) = q.inline_message_id {
+                bot.edit_message_text_inline(&message_id, result)
+                    .parse_mode(ParseMode::Html).disable_web_page_preview(true).reply_markup(InlineKeyboardMarkup::new(keyboard)).await?;
+            } else {
+                bot.send_message(q.from.id, result).parse_mode(ParseMode::Html)
+                    .reply_markup(InlineKeyboardMarkup::new(keyboard))
+                    .link_preview_options(LinkPreviewOptions {
+                        is_disabled: true,
+                        url: None,
+                        prefer_small_media: false,
+                        prefer_large_media: false,
+                        show_above_text: false
+                    }).await?;
+            }
+        },
+        Err(e) => {
+            tracing::error!("{:?}", e);
+            bot.send_message(q.from.id, "Произошла ошибка!").await?;
+        },
+    }
+    Ok(())
+}
+
+async fn generate_list(videos: Vec<(requests::Model, Option<videos::Model>)>, state: &AppState) -> anyhow::Result<Option<String>> {
+    if videos.is_empty() {
+        return Ok(None);
+    }
+    let mut by_date: IndexMap<Date, Vec<Video>> = IndexMap::new();
+    for (request, video) in videos {
+        let video = video.unwrap();
+        let creator = if let Some(c) = request.find_related(actions::Entity).order_by(actions::Column::Id, Order::Asc).one(&state.db).await? {
+            c
+        } else {
+            anyhow::bail!("Can't find creator for {request:?}");
+        };
+
+        let contributors = request.find_related(actions::Entity).count(&state.db).await?;
+        let date = creator.created_at.date();
+        let url = format!("{}{}", youtube::DEFAULT_YT, video.ytid);
+
+        let viewed_times = archived::Entity::find().filter(archived::Column::Ytid.eq(video.ytid.clone())).filter(archived::Column::ViewedAt.is_not_null()).count(&state.db).await?;
+        let archived_times = archived::Entity::find().filter(archived::Column::Ytid.eq(video.ytid)).count(&state.db).await?;
+
+        let mut status = String::new();
+        status.push(if request.viewed_at.is_some() {
+            '👀'
+        } else if viewed_times != 0 {
+            '⭐'
+        } else if archived_times != 0 {
+            '📁'
+        } else {
+            '🆕'
+        });
+
+        if let Some(entry) = by_date.get_mut(&date) {
+            entry.push(Video { id: request.id, title: video.title, url, contributors, status });
+        } else {
+            by_date.insert(date, vec![Video { id: request.id, title: video.title, url, contributors, status }]);
+        };
+    }
+    by_date.sort_unstable_by(|a, _, c, _| c.cmp(a));
+    let mut result = String::new();
+    for (date, mut videos) in by_date {
+        if result.is_empty() {
+            result.push_str(&format!("[{}]", date.format("%d.%m")));
+        } else {
+            result.push_str(&format!("\n[{}]", date.format("%d.%m")));
+        }
+        // result.push_str(&format!(" {}", videos.len()));
+        videos.sort_unstable_by(|a, b| a.contributors.cmp(&b.contributors));
+        for video in videos {
+            let contributors = if video.contributors != 1 {
+                format!("(🙍‍♂️{}) ", video.contributors)
+            } else {
+                String::new()
+            };
+            result.push_str(&format!("\n{}/{} <a href=\"{}\">📺YT</a> {}<b>{}</b>", video.status, video.id, video.url, contributors, video.title));
+            // result.push_str(&format!("\n<a href=\"tg://resolve?domain={}&start=info%20{}\">{}.</a> <b>{}</b> <a href=\"{DEFAULT_YT}{}\">YT</a> ({})", me.username.clone().unwrap(), video.id, video.id, video.title, video.url, video.contributors));
+        }
+    }
+    // result.push_str(&format!("\nВсего: {}", videos_len));
+    Ok(Some(result))
 }

src/handle/mod.rs

@@ -19,6 +19,7 @@ pub fn schema() -> UpdateHandler<anyhow::Error> {
     use dptree::case;
     let moderator_commands = dptree::entry()
         .branch(case![Command::Start].endpoint(start::command_mod))
+        .branch(case![Command::Help].endpoint(start::command_mod))
         .branch(case![Command::List].endpoint(list::command))
         .branch(case![Command::Archive].endpoint(archive::command))
         .branch(case![Command::Mods].endpoint(moderator::list::command))
@@ -73,6 +74,7 @@ pub fn schema() -> UpdateHandler<anyhow::Error> {
             InlineCommand::parse(&q.data?)
         }))
         .branch(case![InlineCommand::Cancel].endpoint(cancel))
+        .branch(case![InlineCommand::ListUnviewed].endpoint(list::inline))
         .branch(filter(|com: InlineCommand| {
             matches!(com, InlineCommand::ArchiveAll | InlineCommand::ArchiveViewed)
         }).endpoint(archive::inline))

src/handle/moderator/remove.rs

@@ -29,7 +29,7 @@ pub async fn inline(bot: Bot, q: CallbackQuery, state: Arc<AppState>, uid: Strin
         if let Some(data) = q.clone().data {
             let text= if &data == "yes" {
                 if let Ok(uid) = uid.parse::<u64>() {
-                    if Entity::delete_by_id(uid as i32).exec(&state.db).await?.rows_affected != 0 {
+                    if Entity::delete_by_id(uid as i64).exec(&state.db).await?.rows_affected != 0 {
                         "Модератор удалён!"
                     } else {
                         "Произошла ошибка!\nПо всей видимости такого модератора не существует."

src/handle/notify.rs

@@ -8,7 +8,7 @@ use crate::AppState;
 
 /// Invert notify status for moderator
 pub async fn command(bot: Bot, msg: Message, uid: UserId, state: Arc<AppState>) -> anyhow::Result<()> {
-    let text = if let Some(moder) = moderators::Entity::find_by_id(uid.0 as i32).one(&state.db).await? {
+    let text = if let Some(moder) = moderators::Entity::find_by_id(uid.0 as i64).one(&state.db).await? {
         let moder = match moder.notify {
             true => {
                 let mut moder = moder.into_active_model();

src/inline.rs

@@ -6,6 +6,7 @@ pub enum InlineCommand {
     Unview(i32),
     ArchiveViewed,
     ArchiveAll,
+    ListUnviewed,
     Cancel,
 }
 
@@ -19,6 +20,7 @@ impl InlineCommand {
             "unview" => Self::Unview(parts.next()?.parse().ok()?),
             "archive_viewed" => Self::ArchiveViewed,
             "archive_all" => Self::ArchiveAll,
+            "list_unviewed" => Self::ListUnviewed,
             "cancel" => Self::Cancel,
             _ => return None,
         })

src/main.rs

@@ -17,6 +17,7 @@ mod markup;
 
 mod inline;
 pub use inline::InlineCommand;
+use url::Url;
 
 pub const COOLDOWN_DURATION: Duration = Duration::from_secs(10);
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
@@ -28,6 +29,12 @@ lazy_static! {
     pub static ref TOKEN: String = {
         var("TOKEN").expect("TOKEN env not set.")
     };
+    pub static ref TELEGRAM_API_URL: Url = {
+        match var("TELEGRAM_API_URL") {
+            Ok(url) => url.parse().expect("Can't parse TELEGRAM_API_URL"),
+            Err(_) => teloxide::net::TELEGRAM_API_URL.parse().expect("Failed to parse default Telegram bot API url")
+        }
+    };
     pub static ref DATABASE_URL: String = {
         var("DATABASE_URL").expect("DATABASE_URL env not set.")
     };
@@ -60,8 +67,8 @@ async fn main() -> anyhow::Result<()> {
     }));
 
     tracing::info!("Doggy-Watch v{VERSION}");
-    tracing::info!("{:?}", *ADMINISTRATORS);
-    let bot = Bot::new(&*TOKEN);
+    tracing::info!("admins: {:?} tg api: {}", *ADMINISTRATORS, TELEGRAM_API_URL.as_str());
+    let bot = Bot::new(&*TOKEN).set_api_url(TELEGRAM_API_URL.clone());
 
     let mut opt = ConnectOptions::new(&*DATABASE_URL);
     opt.sqlx_logging_level(tracing::log::LevelFilter::Trace);
@@ -93,7 +100,7 @@ async fn main() -> anyhow::Result<()> {
         // Pass the shared state to the handler as a dependency.
         .dependencies(dptree::deps![state, InMemStorage::<DialogueState>::new()])
         .default_handler(|upd| async move {
-            tracing::warn!("Unhandled update: {:?}", upd);
+            tracing::debug!("Unhandled update: {:?}", upd);
         })
         .enable_ctrlc_handler()
         .build()
@@ -120,6 +127,8 @@ pub enum DialogueState {
 enum Command {
     #[command(description = "запустить бота и/или вывести этот текст.")]
     Start,
+    #[command(description = "вывести этот текст.")]
+    Help,
     #[command(description = "вывести список.")]
     List,
     #[command(description = "действия с архивом.")]
@@ -184,7 +193,7 @@ impl AppState {
     async fn check_rights(&self, uid: &UserId) -> anyhow::Result<Rights> {
         use database::moderators::Entity as Moderators;
 
-        Ok(if let Some(moder) = Moderators::find_by_id(uid.0 as i32).one(&self.db).await? {
+        Ok(if let Some(moder) = Moderators::find_by_id(uid.0 as i64).one(&self.db).await? {
             Rights::Moderator { can_add_mods: moder.can_add_mods }
         } else {
             Rights::None