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

Cargo.lock

@@ -795,7 +795,7 @@ dependencies = [
 
 [[package]]
 name = "doggy-watch"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "anyhow",
  "chrono",

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
 

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

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 result = generate_list(videos, &state).await;
-        let mut by_date: IndexMap<Date, Vec<Video>> = IndexMap::new();
+    match result {
-        for (request, video) in videos {
+        Ok(list) => {
-            let video = video.unwrap();
+            let result = if let Some(list) = list {
-            let creator = if let Some(c) = request.find_related(actions::Entity).order_by(actions::Column::Id, Order::Asc).one(&state.db).await? {
+                list
-                c
             } else {
-                let data = format!("Can't find creator for {request:?}");
+                "Нет видео для просмотра :(".to_string()
-                bot.send_message(msg.chat.id, data.clone()).await?;
-                anyhow::bail!(data);
             };
 
-            let contributors = request.find_related(actions::Entity).count(&state.db).await?;
+            let keyboard: Vec<Vec<InlineKeyboardButton>> = vec![
-            let date = creator.created_at.date();
+                vec![InlineKeyboardButton::callback("Непросмотренные", "list_unviewed")],
-            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?;
+            bot.send_message(msg.chat.id, result).parse_mode(ParseMode::Html)
-            let archived_times = archived::Entity::find().filter(archived::Column::Ytid.eq(video.ytid)).count(&state.db).await?;
+                .link_preview_options(LinkPreviewOptions { 
-
+                    is_disabled: true,
-            let mut status = String::new();
+                    url: None,
-            status.push(if request.viewed_at.is_some() {
+                    prefer_small_media: false,
-                '👀'
+                    prefer_large_media: false,
-            } else if viewed_times != 0 {
+                    show_above_text: false
-                '⭐'
+                }).reply_markup(InlineKeyboardMarkup::new(keyboard)).await?;
-            } else if archived_times != 0 {
+        },
-                '📁'
+        Err(e) => {
-            } else {
+            tracing::error!("{:?}", e);
-                '🆕'
+            bot.send_message(msg.chat.id, "Произошла ошибка!").await?;
-            });
+        },
-
-            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?;
     }
     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

@@ -74,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/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,
         })