chore: 发布 bili-sync 2.2.0

* feat: 调整并重构视频音频流的选择逻辑，应该可以提升些许性能

* test: 添加少量单元测试

.github/workflows/check.yaml

@@ -26,7 +26,7 @@ jobs:
       - name: Checkout repo
         uses: actions/checkout@v4
 
-      - run: rustup default nightly-2024-04-30 && rustup component add rustfmt clippy
+      - run: rustup default nightly && rustup component add rustfmt clippy
 
       - name: Cache dependencies
         uses: swatinem/rust-cache@v2

Cargo.toml

@@ -4,7 +4,7 @@ default-members = ["crates/bili_sync"]
 resolver = "2"
 
 [workspace.package]
-version = "2.1.0"
+version = "2.2.0"
 authors = ["amtoaer <amtoaer@gmail.com>"]
 license = "MIT"
 description = "由 Rust & Tokio 驱动的哔哩哔哩同步工具"
@@ -15,27 +15,28 @@ publish = false
 bili_sync_entity = { path = "crates/bili_sync_entity" }
 bili_sync_migration = { path = "crates/bili_sync_migration" }
 
-anyhow = { version = "1.0.86", features = ["backtrace"] }
+anyhow = { version = "1.0.95", features = ["backtrace"] }
 arc-swap = { version = "1.7.1", features = ["serde"] }
-async-std = { version = "1.12.0", features = ["attributes", "tokio1"] }
-async-stream = "0.3.5"
-async-trait = "0.1.80"
-chrono = { version = "0.4.38", features = ["serde"] }
-clap = { version = "4.5.8", features = ["env"] }
+async-std = { version = "1.13.0", features = ["attributes", "tokio1"] }
+async-stream = "0.3.6"
+async-trait = "0.1.85"
+chrono = { version = "0.4.39", features = ["serde"] }
+clap = { version = "4.5.26", features = ["env"] }
 cookie = "0.18.1"
-dirs = "5.0.1"
-filenamify = "0.1.0"
+dirs = "6.0.0"
 float-ord = "0.3.2"
-futures = "0.3.30"
-handlebars = "5.1.2"
+futures = "0.3.31"
+handlebars = "6.3.0"
 hex = "0.4.3"
+leaky-bucket = "1.1.2"
+md5 = "0.7.0"
 memchr = "2.7.4"
-once_cell = "1.19.0"
-prost = "0.12.6"
-quick-xml = { version = "0.35.0", features = ["async-tokio"] }
+once_cell = "1.20.2"
+prost = "0.13.4"
+quick-xml = { version = "0.37.2", features = ["async-tokio"] }
 rand = "0.8.5"
-regex = "1.10.5"
-reqwest = { version = "0.12.5", features = [
+regex = "1.11.1"
+reqwest = { version = "0.12.12", features = [
   "charset",
   "cookies",
   "gzip",
@@ -44,21 +45,22 @@ reqwest = { version = "0.12.5", features = [
   "rustls-tls",
   "stream",
 ], default-features = false }
-rsa = { version = "0.9.6", features = ["sha2"] }
-sea-orm = { version = "0.12.15", features = [
+rsa = { version = "0.9.7", features = ["sha2"] }
+sea-orm = { version = "1.1.4", features = [
   "macros",
   "runtime-tokio-rustls",
   "sqlx-sqlite",
 ] }
-sea-orm-migration = { version = "0.12.15", features = [] }
-serde = { version = "1.0.203", features = ["derive"] }
-serde_json = "1.0.120"
+sea-orm-migration = { version = "1.1.4", features = [] }
+serde = { version = "1.0.217", features = ["derive"] }
+serde_json = "1.0.135"
+serde_urlencoded = "0.7.1"
 strum = { version = "0.26.3", features = ["derive"] }
-thiserror = "1.0.61"
-tokio = { version = "1.38.0", features = ["full"] }
-toml = "0.8.14"
-tracing = "0.1.40"
-tracing-subscriber = { version = "0.3.18", features = ["chrono"] }
+thiserror = "2.0.11"
+tokio = { version = "1.43.0", features = ["full"] }
+toml = "0.8.19"
+tracing = "0.1.41"
+tracing-subscriber = { version = "0.3.19", features = ["chrono"] }
 
 [workspace.metadata.release]
 release = false

README.md

@@ -10,13 +10,13 @@ bili-sync 是一款专为 NAS 用户编写的哔哩哔哩同步工具，由 Rust
 ## 效果演示
 
 ### 概览
-![概览](./assets/overview.png)
+![概览](./assets/overview.webp)
 ### 详情
-![详情](./assets/detail.png)
+![详情](./assets/detail.webp)
 ### 播放（使用 infuse）
-![播放](./assets/play.png)
+![播放](./assets/play.webp)
 ### 文件排布
-![文件](./assets/dir.png)
+![文件](./assets/dir.webp)
 
 
 ## 功能与路线图
@@ -30,7 +30,9 @@ bili-sync 是一款专为 NAS 用户编写的哔哩哔哩同步工具，由 Rust
 - [x] 使用数据库保存媒体信息，避免对同个视频的多次请求
 - [x] 打印日志，并在请求出现风控时自动终止，等待下一轮执行
 - [x] 提供多平台的二进制可执行文件，为 Linux 平台提供了立即可用的 Docker 镜像
-- [ ] 支持对“稍后再看”内视频的自动扫描与下载
+- [x] 支持对“稍后再看”内视频的自动扫描与下载
+- [x] 支持对 UP 主投稿视频的自动扫描与下载
+- [x] 支持限制任务的并行度和接口请求频率
 - [ ] 下载单个文件时支持断点续传与并发下载
 
 

crates/bili_sync/Cargo.toml

@@ -19,11 +19,12 @@ chrono = { workspace = true }
 clap = { workspace = true }
 cookie = { workspace = true }
 dirs = { workspace = true }
-filenamify = { workspace = true }
 float-ord = { workspace = true }
 futures = { workspace = true }
 handlebars = { workspace = true }
 hex = { workspace = true }
+leaky-bucket = { workspace = true }
+md5 = { workspace = true }
 memchr = { workspace = true }
 once_cell = { workspace = true }
 prost = { workspace = true }
@@ -35,6 +36,7 @@ rsa = { workspace = true }
 sea-orm = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+serde_urlencoded = { workspace = true }
 strum = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true }

crates/bili_sync/src/adapter/collection.rs

@@ -3,105 +3,53 @@ use std::path::Path;
 use std::pin::Pin;
 
 use anyhow::Result;
+use async_trait::async_trait;
 use bili_sync_entity::*;
-use bili_sync_migration::OnConflict;
-use filenamify::filenamify;
 use futures::Stream;
 use sea_orm::entity::prelude::*;
+use sea_orm::sea_query::{IntoCondition, OnConflict};
 use sea_orm::ActiveValue::Set;
-use sea_orm::{DatabaseConnection, QuerySelect, TransactionTrait};
+use sea_orm::{DatabaseConnection, TransactionTrait};
 
-use super::VideoListModel;
-use crate::bilibili::{BiliClient, BiliError, Collection, CollectionItem, CollectionType, Video, VideoInfo};
-use crate::config::TEMPLATE;
-use crate::utils::id_time_key;
-use crate::utils::model::create_video_pages;
+use crate::adapter::{helper, VideoListModel};
+use crate::bilibili::{self, BiliClient, Collection, CollectionItem, CollectionType, VideoInfo};
 use crate::utils::status::Status;
 
-pub async fn collection_from<'a>(
-    collection_item: &'a CollectionItem,
-    path: &Path,
-    bili_client: &'a BiliClient,
-    connection: &DatabaseConnection,
-) -> Result<(Box<dyn VideoListModel>, Pin<Box<dyn Stream<Item = VideoInfo> + 'a>>)> {
-    let collection = Collection::new(bili_client, collection_item);
-    let collection_info = collection.get_info().await?;
-    collection::Entity::insert(collection::ActiveModel {
-        s_id: Set(collection_info.sid),
-        m_id: Set(collection_info.mid),
-        r#type: Set(collection_info.collection_type.into()),
-        name: Set(collection_info.name.clone()),
-        path: Set(path.to_string_lossy().to_string()),
-        ..Default::default()
-    })
-    .on_conflict(
-        OnConflict::columns([
-            collection::Column::SId,
-            collection::Column::MId,
-            collection::Column::Type,
-        ])
-        .update_columns([collection::Column::Name, collection::Column::Path])
-        .to_owned(),
-    )
-    .exec(connection)
-    .await?;
-    Ok((
-        Box::new(
-            collection::Entity::find()
-                .filter(
-                    collection::Column::SId
-                        .eq(collection_item.sid.clone())
-                        .and(collection::Column::MId.eq(collection_item.mid.clone()))
-                        .and(collection::Column::Type.eq(Into::<i32>::into(collection_item.collection_type.clone()))),
-                )
-                .one(connection)
-                .await?
-                .unwrap(),
-        ),
-        Box::pin(collection.into_simple_video_stream()),
-    ))
-}
-use async_trait::async_trait;
-
 #[async_trait]
 impl VideoListModel for collection::Model {
     async fn video_count(&self, connection: &DatabaseConnection) -> Result<u64> {
-        Ok(video::Entity::find()
-            .filter(video::Column::CollectionId.eq(self.id))
-            .count(connection)
-            .await?)
+        helper::count_videos(video::Column::CollectionId.eq(self.id).into_condition(), connection).await
     }
 
     async fn unfilled_videos(&self, connection: &DatabaseConnection) -> Result<Vec<video::Model>> {
-        Ok(video::Entity::find()
-            .filter(
-                video::Column::CollectionId
-                    .eq(self.id)
-                    .and(video::Column::Valid.eq(true))
-                    .and(video::Column::DownloadStatus.eq(0))
-                    .and(video::Column::Category.eq(2))
-                    .and(video::Column::SinglePage.is_null()),
-            )
-            .all(connection)
-            .await?)
+        helper::filter_videos(
+            video::Column::CollectionId
+                .eq(self.id)
+                .and(video::Column::Valid.eq(true))
+                .and(video::Column::DownloadStatus.eq(0))
+                .and(video::Column::Category.eq(2))
+                .and(video::Column::SinglePage.is_null())
+                .into_condition(),
+            connection,
+        )
+        .await
     }
 
     async fn unhandled_video_pages(
         &self,
         connection: &DatabaseConnection,
     ) -> Result<Vec<(video::Model, Vec<page::Model>)>> {
-        Ok(video::Entity::find()
-            .filter(
-                video::Column::CollectionId
-                    .eq(self.id)
-                    .and(video::Column::Valid.eq(true))
-                    .and(video::Column::DownloadStatus.lt(Status::handled()))
-                    .and(video::Column::Category.eq(2))
-                    .and(video::Column::SinglePage.is_not_null()),
-            )
-            .find_with_related(page::Entity)
-            .all(connection)
-            .await?)
+        helper::filter_videos_with_pages(
+            video::Column::CollectionId
+                .eq(self.id)
+                .and(video::Column::Valid.eq(true))
+                .and(video::Column::DownloadStatus.lt(Status::handled()))
+                .and(video::Column::Category.eq(2))
+                .and(video::Column::SinglePage.is_not_null())
+                .into_condition(),
+            connection,
+        )
+        .await
     }
 
     async fn exist_labels(
@@ -109,77 +57,47 @@ impl VideoListModel for collection::Model {
         videos_info: &[VideoInfo],
         connection: &DatabaseConnection,
     ) -> Result<HashSet<String>> {
-        let bvids = videos_info.iter().map(|v| v.bvid().to_string()).collect::<Vec<_>>();
-        Ok(video::Entity::find()
-            .filter(
-                video::Column::CollectionId
-                    .eq(self.id)
-                    .and(video::Column::Bvid.is_in(bvids)),
-            )
-            .select_only()
-            .columns([video::Column::Bvid, video::Column::Favtime])
-            .into_tuple()
-            .all(connection)
-            .await?
-            .into_iter()
-            .map(|(bvid, time)| id_time_key(&bvid, &time))
-            .collect::<HashSet<_>>())
+        helper::video_keys(
+            video::Column::CollectionId.eq(self.id),
+            videos_info,
+            [video::Column::Bvid, video::Column::Pubtime],
+            connection,
+        )
+        .await
     }
 
     fn video_model_by_info(&self, video_info: &VideoInfo, base_model: Option<video::Model>) -> video::ActiveModel {
         let mut video_model = video_info.to_model(base_model);
         video_model.collection_id = Set(Some(self.id));
-        if let Some(fmt_args) = &video_info.to_fmt_args() {
-            video_model.path = Set(Path::new(&self.path)
-                .join(filenamify(
-                    TEMPLATE
-                        .render("video", fmt_args)
-                        .unwrap_or_else(|_| video_info.bvid().to_string()),
-                ))
-                .to_string_lossy()
-                .to_string());
-        }
-        video_model
+        helper::video_with_path(video_model, &self.path, video_info)
     }
 
     async fn fetch_videos_detail(
         &self,
-        bili_clent: &BiliClient,
-        videos_model: Vec<video::Model>,
+        video: bilibili::Video<'_>,
+        video_model: video::Model,
         connection: &DatabaseConnection,
     ) -> Result<()> {
-        for video_model in videos_model {
-            let video = Video::new(bili_clent, video_model.bvid.clone());
-            let info: Result<_> = async { Ok((video.get_tags().await?, video.get_view_info().await?)) }.await;
-            match info {
-                Ok((tags, view_info)) => {
-                    let VideoInfo::View { pages, .. } = &view_info else {
-                        unreachable!("view_info must be VideoInfo::View")
-                    };
-                    let txn = connection.begin().await?;
-                    // 将分页信息写入数据库
-                    create_video_pages(pages, &video_model, &txn).await?;
-                    // 将页标记和 tag 写入数据库
-                    let mut video_active_model = self.video_model_by_info(&view_info, Some(video_model));
-                    video_active_model.single_page = Set(Some(pages.len() == 1));
-                    video_active_model.tags = Set(Some(serde_json::to_value(tags).unwrap()));
-                    video_active_model.save(&txn).await?;
-                    txn.commit().await?;
-                }
-                Err(e) => {
-                    error!(
-                        "获取视频 {} - {} 的详细信息失败，错误为：{}",
-                        &video_model.bvid, &video_model.name, e
-                    );
-                    if let Some(BiliError::RequestFailed(-404, _)) = e.downcast_ref::<BiliError>() {
-                        let mut video_active_model: video::ActiveModel = video_model.into();
-                        video_active_model.valid = Set(false);
-                        video_active_model.save(connection).await?;
-                    }
-                    continue;
-                }
-            };
-        }
+        let info: Result<_> = async { Ok((video.get_tags().await?, video.get_view_info().await?)) }.await;
+        match info {
+            Ok((tags, view_info)) => {
+                let VideoInfo::View { pages, .. } = &view_info else {
+                    unreachable!("view_info must be VideoInfo::View")
+                };
+                let txn = connection.begin().await?;
+                // 将分页信息写入数据库
+                helper::create_video_pages(pages, &video_model, &txn).await?;
+                // 将页标记和 tag 写入数据库
+                let mut video_active_model = self.video_model_by_info(&view_info, Some(video_model));
+                video_active_model.single_page = Set(Some(pages.len() == 1));
+                video_active_model.tags = Set(Some(serde_json::to_value(tags).unwrap()));
+                video_active_model.save(&txn).await?;
+                txn.commit().await?;
+            }
+            Err(e) => {
+                helper::error_fetch_video_detail(e, video_model, connection).await?;
+            }
+        };
         Ok(())
     }
 
@@ -239,3 +157,47 @@ impl VideoListModel for collection::Model {
         );
     }
 }
+
+pub(super) async fn collection_from<'a>(
+    collection_item: &'a CollectionItem,
+    path: &Path,
+    bili_client: &'a BiliClient,
+    connection: &DatabaseConnection,
+) -> Result<(Box<dyn VideoListModel>, Pin<Box<dyn Stream<Item = VideoInfo> + 'a>>)> {
+    let collection = Collection::new(bili_client, collection_item);
+    let collection_info = collection.get_info().await?;
+    collection::Entity::insert(collection::ActiveModel {
+        s_id: Set(collection_info.sid),
+        m_id: Set(collection_info.mid),
+        r#type: Set(collection_info.collection_type.into()),
+        name: Set(collection_info.name.clone()),
+        path: Set(path.to_string_lossy().to_string()),
+        ..Default::default()
+    })
+    .on_conflict(
+        OnConflict::columns([
+            collection::Column::SId,
+            collection::Column::MId,
+            collection::Column::Type,
+        ])
+        .update_columns([collection::Column::Name, collection::Column::Path])
+        .to_owned(),
+    )
+    .exec(connection)
+    .await?;
+    Ok((
+        Box::new(
+            collection::Entity::find()
+                .filter(
+                    collection::Column::SId
+                        .eq(collection_item.sid.clone())
+                        .and(collection::Column::MId.eq(collection_item.mid.clone()))
+                        .and(collection::Column::Type.eq(Into::<i32>::into(collection_item.collection_type.clone()))),
+                )
+                .one(connection)
+                .await?
+                .unwrap(),
+        ),
+        Box::pin(collection.into_simple_video_stream()),
+    ))
+}

crates/bili_sync/src/adapter/favorite.rs

@@ -3,22 +3,130 @@ use std::path::Path;
 use std::pin::Pin;
 
 use anyhow::Result;
+use async_trait::async_trait;
 use bili_sync_entity::*;
-use bili_sync_migration::OnConflict;
-use filenamify::filenamify;
 use futures::Stream;
 use sea_orm::entity::prelude::*;
+use sea_orm::sea_query::{IntoCondition, OnConflict};
 use sea_orm::ActiveValue::Set;
-use sea_orm::{DatabaseConnection, QuerySelect, TransactionTrait};
+use sea_orm::{DatabaseConnection, TransactionTrait};
 
-use super::VideoListModel;
-use crate::bilibili::{BiliClient, BiliError, FavoriteList, Video, VideoInfo};
-use crate::config::TEMPLATE;
-use crate::utils::id_time_key;
-use crate::utils::model::create_video_pages;
+use crate::adapter::{helper, VideoListModel};
+use crate::bilibili::{self, BiliClient, FavoriteList, VideoInfo};
 use crate::utils::status::Status;
 
-pub async fn favorite_from<'a>(
+#[async_trait]
+impl VideoListModel for favorite::Model {
+    async fn video_count(&self, connection: &DatabaseConnection) -> Result<u64> {
+        helper::count_videos(video::Column::FavoriteId.eq(self.id).into_condition(), connection).await
+    }
+
+    async fn unfilled_videos(&self, connection: &DatabaseConnection) -> Result<Vec<video::Model>> {
+        helper::filter_videos(
+            video::Column::FavoriteId
+                .eq(self.id)
+                .and(video::Column::Valid.eq(true))
+                .and(video::Column::DownloadStatus.eq(0))
+                .and(video::Column::Category.eq(2))
+                .and(video::Column::SinglePage.is_null())
+                .into_condition(),
+            connection,
+        )
+        .await
+    }
+
+    async fn unhandled_video_pages(
+        &self,
+        connection: &DatabaseConnection,
+    ) -> Result<Vec<(video::Model, Vec<page::Model>)>> {
+        helper::filter_videos_with_pages(
+            video::Column::FavoriteId
+                .eq(self.id)
+                .and(video::Column::Valid.eq(true))
+                .and(video::Column::DownloadStatus.lt(Status::handled()))
+                .and(video::Column::Category.eq(2))
+                .and(video::Column::SinglePage.is_not_null())
+                .into_condition(),
+            connection,
+        )
+        .await
+    }
+
+    async fn exist_labels(
+        &self,
+        videos_info: &[VideoInfo],
+        connection: &DatabaseConnection,
+    ) -> Result<HashSet<String>> {
+        helper::video_keys(
+            video::Column::FavoriteId.eq(self.id),
+            videos_info,
+            [video::Column::Bvid, video::Column::Favtime],
+            connection,
+        )
+        .await
+    }
+
+    fn video_model_by_info(&self, video_info: &VideoInfo, base_model: Option<video::Model>) -> video::ActiveModel {
+        let mut video_model = video_info.to_model(base_model);
+        video_model.favorite_id = Set(Some(self.id));
+        helper::video_with_path(video_model, &self.path, video_info)
+    }
+
+    async fn fetch_videos_detail(
+        &self,
+        video: bilibili::Video<'_>,
+        video_model: video::Model,
+        connection: &DatabaseConnection,
+    ) -> Result<()> {
+        let info: Result<_> = async { Ok((video.get_tags().await?, video.get_pages().await?)) }.await;
+        match info {
+            Ok((tags, pages_info)) => {
+                let txn = connection.begin().await?;
+                // 将分页信息写入数据库
+                helper::create_video_pages(&pages_info, &video_model, &txn).await?;
+                // 将页标记和 tag 写入数据库
+                let mut video_active_model: video::ActiveModel = video_model.into();
+                video_active_model.single_page = Set(Some(pages_info.len() == 1));
+                video_active_model.tags = Set(Some(serde_json::to_value(tags).unwrap()));
+                video_active_model.save(&txn).await?;
+                txn.commit().await?;
+            }
+            Err(e) => {
+                helper::error_fetch_video_detail(e, video_model, connection).await?;
+            }
+        };
+        Ok(())
+    }
+
+    fn log_fetch_video_start(&self) {
+        info!("开始获取收藏夹 {} - {} 的视频与分页信息...", self.f_id, self.name);
+    }
+
+    fn log_fetch_video_end(&self) {
+        info!("获取收藏夹 {} - {} 的视频与分页信息完成", self.f_id, self.name);
+    }
+
+    fn log_download_video_start(&self) {
+        info!("开始下载收藏夹: {} - {} 中所有未处理过的视频...", self.f_id, self.name);
+    }
+
+    fn log_download_video_end(&self) {
+        info!("下载收藏夹: {} - {} 中未处理过的视频完成", self.f_id, self.name);
+    }
+
+    fn log_refresh_video_start(&self) {
+        info!("开始扫描收藏夹: {} - {} 的新视频...", self.f_id, self.name);
+    }
+
+    fn log_refresh_video_end(&self, got_count: usize, new_count: u64) {
+        info!(
+            "扫描收藏夹: {} - {} 的新视频完成，获取了 {} 条新视频，其中有 {} 条新视频",
+            self.f_id, self.name, got_count, new_count
+        );
+    }
+}
+
+pub(super) async fn favorite_from<'a>(
     fid: &str,
     path: &Path,
     bili_client: &'a BiliClient,
@@ -50,150 +158,3 @@ pub async fn favorite_from<'a>(
         Box::pin(favorite.into_video_stream()),
     ))
 }
-
-use async_trait::async_trait;
-
-#[async_trait]
-impl VideoListModel for favorite::Model {
-    async fn video_count(&self, connection: &DatabaseConnection) -> Result<u64> {
-        Ok(video::Entity::find()
-            .filter(video::Column::FavoriteId.eq(self.id))
-            .count(connection)
-            .await?)
-    }
-
-    async fn unfilled_videos(&self, connection: &DatabaseConnection) -> Result<Vec<video::Model>> {
-        Ok(video::Entity::find()
-            .filter(
-                video::Column::FavoriteId
-                    .eq(self.id)
-                    .and(video::Column::Valid.eq(true))
-                    .and(video::Column::DownloadStatus.eq(0))
-                    .and(video::Column::Category.eq(2))
-                    .and(video::Column::SinglePage.is_null()),
-            )
-            .all(connection)
-            .await?)
-    }
-
-    async fn unhandled_video_pages(
-        &self,
-        connection: &DatabaseConnection,
-    ) -> Result<Vec<(video::Model, Vec<page::Model>)>> {
-        Ok(video::Entity::find()
-            .filter(
-                video::Column::FavoriteId
-                    .eq(self.id)
-                    .and(video::Column::Valid.eq(true))
-                    .and(video::Column::DownloadStatus.lt(Status::handled()))
-                    .and(video::Column::Category.eq(2))
-                    .and(video::Column::SinglePage.is_not_null()),
-            )
-            .find_with_related(page::Entity)
-            .all(connection)
-            .await?)
-    }
-
-    async fn exist_labels(
-        &self,
-        videos_info: &[VideoInfo],
-        connection: &DatabaseConnection,
-    ) -> Result<HashSet<String>> {
-        let bvids = videos_info.iter().map(|v| v.bvid().to_string()).collect::<Vec<_>>();
-        Ok(video::Entity::find()
-            .filter(
-                video::Column::FavoriteId
-                    .eq(self.id)
-                    .and(video::Column::Bvid.is_in(bvids)),
-            )
-            .select_only()
-            .columns([video::Column::Bvid, video::Column::Favtime])
-            .into_tuple()
-            .all(connection)
-            .await?
-            .into_iter()
-            .map(|(bvid, time)| id_time_key(&bvid, &time))
-            .collect::<HashSet<_>>())
-    }
-
-    fn video_model_by_info(&self, video_info: &VideoInfo, base_model: Option<video::Model>) -> video::ActiveModel {
-        let mut video_model = video_info.to_model(base_model);
-        video_model.favorite_id = Set(Some(self.id));
-        if let Some(fmt_args) = &video_info.to_fmt_args() {
-            video_model.path = Set(Path::new(&self.path)
-                .join(filenamify(
-                    TEMPLATE
-                        .render("video", fmt_args)
-                        .unwrap_or_else(|_| video_info.bvid().to_string()),
-                ))
-                .to_string_lossy()
-                .to_string());
-        }
-        video_model
-    }
-
-    async fn fetch_videos_detail(
-        &self,
-        bili_clent: &BiliClient,
-        videos_model: Vec<video::Model>,
-        connection: &DatabaseConnection,
-    ) -> Result<()> {
-        for video_model in videos_model {
-            let video = Video::new(bili_clent, video_model.bvid.clone());
-            let info: Result<_> = async { Ok((video.get_tags().await?, video.get_pages().await?)) }.await;
-            match info {
-                Ok((tags, pages_info)) => {
-                    let txn = connection.begin().await?;
-                    // 将分页信息写入数据库
-                    create_video_pages(&pages_info, &video_model, &txn).await?;
-                    // 将页标记和 tag 写入数据库
-                    let mut video_active_model: video::ActiveModel = video_model.into();
-                    video_active_model.single_page = Set(Some(pages_info.len() == 1));
-                    video_active_model.tags = Set(Some(serde_json::to_value(tags).unwrap()));
-                    video_active_model.save(&txn).await?;
-                    txn.commit().await?;
-                }
-                Err(e) => {
-                    error!(
-                        "获取视频 {} - {} 的详细信息失败，错误为：{}",
-                        &video_model.bvid, &video_model.name, e
-                    );
-                    if let Some(BiliError::RequestFailed(-404, _)) = e.downcast_ref::<BiliError>() {
-                        let mut video_active_model: video::ActiveModel = video_model.into();
-                        video_active_model.valid = Set(false);
-                        video_active_model.save(connection).await?;
-                    }
-                    continue;
-                }
-            };
-        }
-        Ok(())
-    }
-
-    fn log_fetch_video_start(&self) {
-        info!("开始获取收藏夹 {} - {} 的视频与分页信息...", self.f_id, self.name);
-    }
-
-    fn log_fetch_video_end(&self) {
-        info!("获取收藏夹 {} - {} 的视频与分页信息完成", self.f_id, self.name);
-    }
-
-    fn log_download_video_start(&self) {
-        info!("开始下载收藏夹: {} - {} 中所有未处理过的视频...", self.f_id, self.name);
-    }
-
-    fn log_download_video_end(&self) {
-        info!("下载收藏夹: {} - {} 中未处理过的视频完成", self.f_id, self.name);
-    }
-
-    fn log_refresh_video_start(&self) {
-        info!("开始扫描收藏夹: {} - {} 的新视频...", self.f_id, self.name);
-    }
-
-    fn log_refresh_video_end(&self, got_count: usize, new_count: u64) {
-        info!(
-            "扫描收藏夹: {} - {} 的新视频完成，获取了 {} 条新视频，其中有 {} 条新视频",
-            self.f_id, self.name, got_count, new_count
-        );
-    }
-}

crates/bili_sync/src/adapter/helper/mod.rs

@@ -0,0 +1,138 @@
+use std::collections::HashSet;
+use std::path::Path;
+
+use anyhow::Result;
+use bili_sync_entity::*;
+use sea_orm::entity::prelude::*;
+use sea_orm::sea_query::{OnConflict, SimpleExpr};
+use sea_orm::ActiveValue::Set;
+use sea_orm::{Condition, DatabaseTransaction, QuerySelect};
+
+use crate::bilibili::{BiliError, PageInfo, VideoInfo};
+use crate::config::{PathSafeTemplate, TEMPLATE};
+use crate::utils::id_time_key;
+
+/// 使用 condition 筛选视频，返回视频数量
+pub(super) async fn count_videos(condition: Condition, conn: &DatabaseConnection) -> Result<u64> {
+    Ok(video::Entity::find().filter(condition).count(conn).await?)
+}
+
+/// 使用 condition 筛选视频，返回视频列表
+pub(super) async fn filter_videos(condition: Condition, conn: &DatabaseConnection) -> Result<Vec<video::Model>> {
+    Ok(video::Entity::find().filter(condition).all(conn).await?)
+}
+
+/// 使用 condition 筛选视频，返回视频列表和相关的分 P 列表
+pub(super) async fn filter_videos_with_pages(
+    condition: Condition,
+    conn: &DatabaseConnection,
+) -> Result<Vec<(video::Model, Vec<page::Model>)>> {
+    Ok(video::Entity::find()
+        .filter(condition)
+        .find_with_related(page::Entity)
+        .all(conn)
+        .await?)
+}
+
+/// 返回 videos_info 存在于视频表里那部分对应的 key
+pub(super) async fn video_keys(
+    expr: SimpleExpr,
+    videos_info: &[VideoInfo],
+    columns: [video::Column; 2],
+    conn: &DatabaseConnection,
+) -> Result<HashSet<String>> {
+    Ok(video::Entity::find()
+        .filter(
+            video::Column::Bvid
+                .is_in(videos_info.iter().map(|v| v.bvid().to_string()))
+                .and(expr),
+        )
+        .select_only()
+        .columns(columns)
+        .into_tuple()
+        .all(conn)
+        .await?
+        .into_iter()
+        .map(|(bvid, time)| id_time_key(&bvid, &time))
+        .collect())
+}
+
+/// 返回设置了 path 的视频
+pub(super) fn video_with_path(
+    mut video_model: video::ActiveModel,
+    base_path: &str,
+    video_info: &VideoInfo,
+) -> video::ActiveModel {
+    if let Some(fmt_args) = &video_info.to_fmt_args() {
+        video_model.path = Set(Path::new(base_path)
+            .join(TEMPLATE.path_safe_render("video", fmt_args).unwrap())
+            .to_string_lossy()
+            .to_string());
+    }
+    video_model
+}
+
+/// 处理获取视频详细信息失败的情况
+pub(super) async fn error_fetch_video_detail(
+    e: anyhow::Error,
+    video_model: bili_sync_entity::video::Model,
+    connection: &DatabaseConnection,
+) -> Result<()> {
+    error!(
+        "获取视频 {} - {} 的详细信息失败，错误为：{}",
+        &video_model.bvid, &video_model.name, e
+    );
+    if let Some(BiliError::RequestFailed(-404, _)) = e.downcast_ref::<BiliError>() {
+        let mut video_active_model: bili_sync_entity::video::ActiveModel = video_model.into();
+        video_active_model.valid = Set(false);
+        video_active_model.save(connection).await?;
+    }
+    Ok(())
+}
+
+/// 创建视频的所有分 P
+pub(crate) async fn create_video_pages(
+    pages_info: &[PageInfo],
+    video_model: &video::Model,
+    connection: &DatabaseTransaction,
+) -> Result<()> {
+    let page_models = pages_info
+        .iter()
+        .map(move |p| {
+            let (width, height) = match &p.dimension {
+                Some(d) => {
+                    if d.rotate == 0 {
+                        (Some(d.width), Some(d.height))
+                    } else {
+                        (Some(d.height), Some(d.width))
+                    }
+                }
+                None => (None, None),
+            };
+            page::ActiveModel {
+                video_id: Set(video_model.id),
+                cid: Set(p.cid),
+                pid: Set(p.page),
+                name: Set(p.name.clone()),
+                width: Set(width),
+                height: Set(height),
+                duration: Set(p.duration),
+                image: Set(p.first_frame.clone()),
+                download_status: Set(0),
+                ..Default::default()
+            }
+        })
+        .collect::<Vec<page::ActiveModel>>();
+    for page_chunk in page_models.chunks(50) {
+        page::Entity::insert_many(page_chunk.to_vec())
+            .on_conflict(
+                OnConflict::columns([page::Column::VideoId, page::Column::Pid])
+                    .do_nothing()
+                    .to_owned(),
+            )
+            .do_nothing()
+            .exec(connection)
+            .await?;
+    }
+    Ok(())
+}

crates/bili_sync/src/adapter/mod.rs

@@ -1,5 +1,8 @@
 mod collection;
 mod favorite;
+mod helper;
+mod submission;
+mod watch_later;
 
 use std::collections::HashSet;
 use std::path::Path;
@@ -7,16 +10,21 @@ use std::pin::Pin;
 
 use anyhow::Result;
 use async_trait::async_trait;
-pub use collection::collection_from;
-pub use favorite::favorite_from;
 use futures::Stream;
+use sea_orm::entity::prelude::*;
 use sea_orm::DatabaseConnection;
 
-use crate::bilibili::{BiliClient, CollectionItem, VideoInfo};
+use crate::adapter::collection::collection_from;
+use crate::adapter::favorite::favorite_from;
+use crate::adapter::submission::submission_from;
+use crate::adapter::watch_later::watch_later_from;
+use crate::bilibili::{self, BiliClient, CollectionItem, VideoInfo};
 
 pub enum Args<'a> {
     Favorite { fid: &'a str },
     Collection { collection_item: &'a CollectionItem },
+    WatchLater,
+    Submission { upper_id: &'a str },
 }
 
 pub async fn video_list_from<'a>(
@@ -28,54 +36,59 @@ pub async fn video_list_from<'a>(
     match args {
         Args::Favorite { fid } => favorite_from(fid, path, bili_client, connection).await,
         Args::Collection { collection_item } => collection_from(collection_item, path, bili_client, connection).await,
+        Args::WatchLater => watch_later_from(path, bili_client, connection).await,
+        Args::Submission { upper_id } => submission_from(upper_id, path, bili_client, connection).await,
     }
 }
 
 #[async_trait]
 pub trait VideoListModel {
-    /* 逻辑相关 */
-
-    /// 获取与视频列表关联的视频总数
+    /// 与视频列表关联的视频总数
     async fn video_count(&self, connection: &DatabaseConnection) -> Result<u64>;
 
-    /// 获取未填充的视频
+    /// 未填充的视频
     async fn unfilled_videos(&self, connection: &DatabaseConnection) -> Result<Vec<bili_sync_entity::video::Model>>;
 
-    /// 获取未处理的视频和分页
+    /// 未处理的视频和分页
     async fn unhandled_video_pages(
         &self,
         connection: &DatabaseConnection,
     ) -> Result<Vec<(bili_sync_entity::video::Model, Vec<bili_sync_entity::page::Model>)>>;
 
-    /// 获取该批次视频的存在标记
+    /// 该批次视频的存在标记
     async fn exist_labels(&self, videos_info: &[VideoInfo], connection: &DatabaseConnection)
         -> Result<HashSet<String>>;
 
-    /// 获取视频信息对应的视频 model
+    /// 视频信息对应的视频 model
     fn video_model_by_info(
         &self,
         video_info: &VideoInfo,
         base_model: Option<bili_sync_entity::video::Model>,
     ) -> bili_sync_entity::video::ActiveModel;
 
-    /// 获取视频 model 中缺失的信息
+    /// 视频 model 中缺失的信息
     async fn fetch_videos_detail(
         &self,
-        bili_client: &BiliClient,
-        videos_model: Vec<bili_sync_entity::video::Model>,
+        video: bilibili::Video<'_>,
+        video_model: bili_sync_entity::video::Model,
         connection: &DatabaseConnection,
     ) -> Result<()>;
 
-    /* 日志相关 */
+    /// 开始获取视频
     fn log_fetch_video_start(&self);
 
+    /// 结束获取视频
     fn log_fetch_video_end(&self);
 
+    /// 开始下载视频
     fn log_download_video_start(&self);
 
+    /// 结束下载视频
     fn log_download_video_end(&self);
 
+    /// 开始刷新视频
     fn log_refresh_video_start(&self);
 
+    /// 结束刷新视频
     fn log_refresh_video_end(&self, got_count: usize, new_count: u64);
 }

crates/bili_sync/src/adapter/submission.rs

@@ -0,0 +1,176 @@
+use std::collections::HashSet;
+use std::path::Path;
+use std::pin::Pin;
+
+use anyhow::Result;
+use async_trait::async_trait;
+use bili_sync_entity::*;
+use futures::Stream;
+use sea_orm::entity::prelude::*;
+use sea_orm::sea_query::{IntoCondition, OnConflict};
+use sea_orm::ActiveValue::Set;
+use sea_orm::{DatabaseConnection, TransactionTrait};
+
+use crate::adapter::helper::video_with_path;
+use crate::adapter::{helper, VideoListModel};
+use crate::bilibili::{self, BiliClient, Submission, VideoInfo};
+use crate::utils::status::Status;
+
+#[async_trait]
+impl VideoListModel for submission::Model {
+    async fn video_count(&self, connection: &DatabaseConnection) -> Result<u64> {
+        helper::count_videos(video::Column::SubmissionId.eq(self.id).into_condition(), connection).await
+    }
+
+    async fn unfilled_videos(&self, connection: &DatabaseConnection) -> Result<Vec<video::Model>> {
+        helper::filter_videos(
+            video::Column::SubmissionId
+                .eq(self.id)
+                .and(video::Column::Valid.eq(true))
+                .and(video::Column::DownloadStatus.eq(0))
+                .and(video::Column::Category.eq(2))
+                .and(video::Column::SinglePage.is_null())
+                .into_condition(),
+            connection,
+        )
+        .await
+    }
+
+    async fn unhandled_video_pages(
+        &self,
+        connection: &DatabaseConnection,
+    ) -> Result<Vec<(video::Model, Vec<page::Model>)>> {
+        helper::filter_videos_with_pages(
+            video::Column::SubmissionId
+                .eq(self.id)
+                .and(video::Column::Valid.eq(true))
+                .and(video::Column::DownloadStatus.lt(Status::handled()))
+                .and(video::Column::Category.eq(2))
+                .and(video::Column::SinglePage.is_not_null())
+                .into_condition(),
+            connection,
+        )
+        .await
+    }
+
+    async fn exist_labels(
+        &self,
+        videos_info: &[VideoInfo],
+        connection: &DatabaseConnection,
+    ) -> Result<HashSet<String>> {
+        helper::video_keys(
+            video::Column::SubmissionId.eq(self.id),
+            videos_info,
+            [video::Column::Bvid, video::Column::Ctime],
+            connection,
+        )
+        .await
+    }
+
+    fn video_model_by_info(&self, video_info: &VideoInfo, base_model: Option<video::Model>) -> video::ActiveModel {
+        let mut video_model = video_info.to_model(base_model);
+        video_model.submission_id = Set(Some(self.id));
+        video_with_path(video_model, &self.path, video_info)
+    }
+
+    async fn fetch_videos_detail(
+        &self,
+        video: bilibili::Video<'_>,
+        video_model: video::Model,
+        connection: &DatabaseConnection,
+    ) -> Result<()> {
+        let info: Result<_> = async { Ok((video.get_tags().await?, video.get_view_info().await?)) }.await;
+        match info {
+            Ok((tags, view_info)) => {
+                let VideoInfo::View { pages, .. } = &view_info else {
+                    unreachable!("view_info must be VideoInfo::View")
+                };
+                let txn = connection.begin().await?;
+                // 将分页信息写入数据库
+                helper::create_video_pages(pages, &video_model, &txn).await?;
+                // 将页标记和 tag 写入数据库
+                let mut video_active_model = self.video_model_by_info(&view_info, Some(video_model));
+                video_active_model.single_page = Set(Some(pages.len() == 1));
+                video_active_model.tags = Set(Some(serde_json::to_value(tags).unwrap()));
+                video_active_model.save(&txn).await?;
+                txn.commit().await?;
+            }
+            Err(e) => {
+                helper::error_fetch_video_detail(e, video_model, connection).await?;
+            }
+        };
+        Ok(())
+    }
+
+    fn log_fetch_video_start(&self) {
+        info!(
+            "开始获取 UP 主 {} - {} 投稿的视频与分页信息...",
+            self.upper_id, self.upper_name
+        );
+    }
+
+    fn log_fetch_video_end(&self) {
+        info!(
+            "获取 UP 主 {} - {} 投稿的视频与分页信息完成",
+            self.upper_id, self.upper_name
+        );
+    }
+
+    fn log_download_video_start(&self) {
+        info!(
+            "开始下载 UP 主 {} - {} 投稿的所有未处理过的视频...",
+            self.upper_id, self.upper_name
+        );
+    }
+
+    fn log_download_video_end(&self) {
+        info!(
+            "下载 UP 主 {} - {} 投稿的所有未处理过的视频完成",
+            self.upper_id, self.upper_name
+        );
+    }
+
+    fn log_refresh_video_start(&self) {
+        info!("开始扫描 UP 主 {} - {} 投稿的新视频...", self.upper_id, self.upper_name);
+    }
+
+    fn log_refresh_video_end(&self, got_count: usize, new_count: u64) {
+        info!(
+            "扫描 UP 主 {} - {} 投稿的新视频完成，获取了 {} 条新视频，其中有 {} 条新视频",
+            self.upper_id, self.upper_name, got_count, new_count,
+        );
+    }
+}
+
+pub(super) async fn submission_from<'a>(
+    upper_id: &str,
+    path: &Path,
+    bili_client: &'a BiliClient,
+    connection: &DatabaseConnection,
+) -> Result<(Box<dyn VideoListModel>, Pin<Box<dyn Stream<Item = VideoInfo> + 'a>>)> {
+    let submission = Submission::new(bili_client, upper_id.to_owned());
+    let upper = submission.get_info().await?;
+    submission::Entity::insert(submission::ActiveModel {
+        upper_id: Set(upper.mid.parse()?),
+        upper_name: Set(upper.name),
+        path: Set(path.to_string_lossy().to_string()),
+        ..Default::default()
+    })
+    .on_conflict(
+        OnConflict::column(submission::Column::UpperId)
+            .update_columns([submission::Column::UpperName, submission::Column::Path])
+            .to_owned(),
+    )
+    .exec(connection)
+    .await?;
+    Ok((
+        Box::new(
+            submission::Entity::find()
+                .filter(submission::Column::UpperId.eq(upper.mid))
+                .one(connection)
+                .await?
+                .unwrap(),
+        ),
+        Box::pin(submission.into_video_stream()),
+    ))
+}

crates/bili_sync/src/adapter/watch_later.rs

@@ -0,0 +1,158 @@
+use std::collections::HashSet;
+use std::path::Path;
+use std::pin::Pin;
+
+use anyhow::Result;
+use async_trait::async_trait;
+use bili_sync_entity::*;
+use futures::Stream;
+use sea_orm::entity::prelude::*;
+use sea_orm::sea_query::{IntoCondition, OnConflict};
+use sea_orm::ActiveValue::Set;
+use sea_orm::{DatabaseConnection, TransactionTrait};
+
+use crate::adapter::helper::video_with_path;
+use crate::adapter::{helper, VideoListModel};
+use crate::bilibili::{self, BiliClient, VideoInfo, WatchLater};
+use crate::utils::status::Status;
+
+#[async_trait]
+impl VideoListModel for watch_later::Model {
+    async fn video_count(&self, connection: &DatabaseConnection) -> Result<u64> {
+        helper::count_videos(video::Column::WatchLaterId.eq(self.id).into_condition(), connection).await
+    }
+
+    async fn unfilled_videos(&self, connection: &DatabaseConnection) -> Result<Vec<video::Model>> {
+        helper::filter_videos(
+            video::Column::WatchLaterId
+                .eq(self.id)
+                .and(video::Column::Valid.eq(true))
+                .and(video::Column::DownloadStatus.eq(0))
+                .and(video::Column::Category.eq(2))
+                .and(video::Column::SinglePage.is_null())
+                .into_condition(),
+            connection,
+        )
+        .await
+    }
+
+    async fn unhandled_video_pages(
+        &self,
+        connection: &DatabaseConnection,
+    ) -> Result<Vec<(video::Model, Vec<page::Model>)>> {
+        helper::filter_videos_with_pages(
+            video::Column::WatchLaterId
+                .eq(self.id)
+                .and(video::Column::Valid.eq(true))
+                .and(video::Column::DownloadStatus.lt(Status::handled()))
+                .and(video::Column::Category.eq(2))
+                .and(video::Column::SinglePage.is_not_null())
+                .into_condition(),
+            connection,
+        )
+        .await
+    }
+
+    async fn exist_labels(
+        &self,
+        videos_info: &[VideoInfo],
+        connection: &DatabaseConnection,
+    ) -> Result<HashSet<String>> {
+        helper::video_keys(
+            video::Column::WatchLaterId.eq(self.id),
+            videos_info,
+            [video::Column::Bvid, video::Column::Favtime],
+            connection,
+        )
+        .await
+    }
+
+    fn video_model_by_info(&self, video_info: &VideoInfo, base_model: Option<video::Model>) -> video::ActiveModel {
+        let mut video_model = video_info.to_model(base_model);
+        video_model.watch_later_id = Set(Some(self.id));
+        video_with_path(video_model, &self.path, video_info)
+    }
+
+    async fn fetch_videos_detail(
+        &self,
+        video: bilibili::Video<'_>,
+        video_model: video::Model,
+        connection: &DatabaseConnection,
+    ) -> Result<()> {
+        let info: Result<_> = async { Ok((video.get_tags().await?, video.get_pages().await?)) }.await;
+        match info {
+            Ok((tags, pages_info)) => {
+                let txn = connection.begin().await?;
+                // 将分页信息写入数据库
+                helper::create_video_pages(&pages_info, &video_model, &txn).await?;
+                // 将页标记和 tag 写入数据库
+                let mut video_active_model: video::ActiveModel = video_model.into();
+                video_active_model.single_page = Set(Some(pages_info.len() == 1));
+                video_active_model.tags = Set(Some(serde_json::to_value(tags).unwrap()));
+                video_active_model.save(&txn).await?;
+                txn.commit().await?;
+            }
+            Err(e) => {
+                helper::error_fetch_video_detail(e, video_model, connection).await?;
+            }
+        };
+        Ok(())
+    }
+
+    fn log_fetch_video_start(&self) {
+        info!("开始获取稍后再看的视频与分页信息...");
+    }
+
+    fn log_fetch_video_end(&self) {
+        info!("获取稍后再看的视频与分页信息完成");
+    }
+
+    fn log_download_video_start(&self) {
+        info!("开始下载稍后再看中所有未处理过的视频...");
+    }
+
+    fn log_download_video_end(&self) {
+        info!("下载稍后再看中未处理过的视频完成");
+    }
+
+    fn log_refresh_video_start(&self) {
+        info!("开始扫描稍后再看的新视频...");
+    }
+
+    fn log_refresh_video_end(&self, got_count: usize, new_count: u64) {
+        info!(
+            "扫描稍后再看的新视频完成，获取了 {} 条新视频，其中有 {} 条新视频",
+            got_count, new_count,
+        );
+    }
+}
+
+pub(super) async fn watch_later_from<'a>(
+    path: &Path,
+    bili_client: &'a BiliClient,
+    connection: &DatabaseConnection,
+) -> Result<(Box<dyn VideoListModel>, Pin<Box<dyn Stream<Item = VideoInfo> + 'a>>)> {
+    let watch_later = WatchLater::new(bili_client);
+    watch_later::Entity::insert(watch_later::ActiveModel {
+        id: Set(1),
+        path: Set(path.to_string_lossy().to_string()),
+        ..Default::default()
+    })
+    .on_conflict(
+        OnConflict::column(watch_later::Column::Id)
+            .update_column(watch_later::Column::Path)
+            .to_owned(),
+    )
+    .exec(connection)
+    .await?;
+    Ok((
+        Box::new(
+            watch_later::Entity::find()
+                .filter(watch_later::Column::Id.eq(1))
+                .one(connection)
+                .await?
+                .unwrap(),
+        ),
+        Box::pin(watch_later.into_video_stream()),
+    ))
+}

crates/bili_sync/src/bilibili/analyzer.rs

@@ -20,7 +20,8 @@ pub enum VideoQuality {
     QualityDolby = 126,
     Quality8k = 127,
 }
-#[derive(Debug, strum::FromRepr, PartialEq, PartialOrd, Serialize, Deserialize)]
+
+#[derive(Debug, Clone, Copy, strum::FromRepr, PartialEq, Serialize, Deserialize)]
 pub enum AudioQuality {
     Quality64k = 30216,
     Quality132k = 30232,
@@ -29,8 +30,25 @@ pub enum AudioQuality {
     Quality192k = 30280,
 }
 
+impl AudioQuality {
+    #[inline]
+    pub fn as_sort_key(&self) -> isize {
+        match self {
+            // 这可以让 Dolby 和 Hi-RES 排在 192k 之后，且 Dolby 和 Hi-RES 之间的顺序不变
+            Self::QualityHiRES | Self::QualityDolby => (*self as isize) + 40,
+            _ => *self as isize,
+        }
+    }
+}
+
+impl PartialOrd<AudioQuality> for AudioQuality {
+    fn partial_cmp(&self, other: &AudioQuality) -> Option<std::cmp::Ordering> {
+        self.as_sort_key().partial_cmp(&other.as_sort_key())
+    }
+}
+
 #[allow(clippy::upper_case_acronyms)]
-#[derive(Debug, strum::EnumString, strum::Display, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Debug, strum::EnumString, strum::Display, strum::AsRefStr, PartialEq, PartialOrd, Serialize, Deserialize)]
 pub enum VideoCodecs {
     #[strum(serialize = "hev")]
     HEV,
@@ -115,26 +133,22 @@ impl PageAnalyzer {
     }
 
     fn is_flv_stream(&self) -> bool {
-        self.info.get("durl").is_some()
-            && self.info["format"].is_string()
-            && self.info["format"].as_str().unwrap().starts_with("flv")
+        self.info.get("durl").is_some() && self.info["format"].as_str().is_some_and(|f| f.starts_with("flv"))
     }
 
     fn is_html5_mp4_stream(&self) -> bool {
         self.info.get("durl").is_some()
-            && self.info["format"].is_string()
-            && self.info["format"].as_str().unwrap().starts_with("mp4")
-            && self.info["is_html5"].is_boolean()
-            && self.info["is_html5"].as_bool().unwrap()
+            && self.info["format"].as_str().is_some_and(|f| f.starts_with("mp4"))
+            && self.info["is_html5"].as_bool().is_some_and(|b| b)
     }
 
     fn is_episode_try_mp4_stream(&self) -> bool {
         self.info.get("durl").is_some()
-            && self.info["format"].is_string()
-            && self.info["format"].as_str().unwrap().starts_with("mp4")
-            && !(self.info["is_html5"].is_boolean() && self.info["is_html5"].as_bool().unwrap())
+            && self.info["format"].as_str().is_some_and(|f| f.starts_with("mp4"))
+            && self.info["is_html5"].as_bool().is_none_or(|b| !b)
     }
 
+    /// 获取所有的视频、音频流，并根据条件筛选
     fn streams(&mut self, filter_option: &FilterOption) -> Result<Vec<Stream>> {
         if self.is_flv_stream() {
             return Ok(vec![Stream::Flv(
@@ -161,85 +175,81 @@ impl PageAnalyzer {
             )]);
         }
         let mut streams: Vec<Stream> = Vec::new();
-        let videos_data = self.info["dash"]["video"].take();
-        let audios_data = self.info["dash"]["audio"].take();
-        let flac_data = self.info["dash"]["flac"].take();
-        let dolby_data = self.info["dash"]["dolby"].take();
-        for video_data in videos_data.as_array().ok_or(BiliError::RiskControlOccurred)?.iter() {
-            let video_stream_url = video_data["baseUrl"].as_str().unwrap().to_string();
-            let video_stream_quality = VideoQuality::from_repr(video_data["id"].as_u64().unwrap() as usize)
-                .ok_or(anyhow!("invalid video stream quality"))?;
-            if (video_stream_quality == VideoQuality::QualityHdr && filter_option.no_hdr)
-                || (video_stream_quality == VideoQuality::QualityDolby && filter_option.no_dolby_video)
-                || (video_stream_quality != VideoQuality::QualityDolby
-                    && video_stream_quality != VideoQuality::QualityHdr
-                    && (video_stream_quality < filter_option.video_min_quality
-                        || video_stream_quality > filter_option.video_max_quality))
-            // 此处过滤包含三种情况：
-            // 1. HDR 视频，但指定不需要 HDR
-            // 2. 杜比视界视频，但指定不需要杜比视界
-            // 3. 视频质量不在指定范围内
+        for video in self.info["dash"]["video"]
+            .as_array()
+            .ok_or(BiliError::RiskControlOccurred)?
+            .iter()
+        {
+            let (Some(url), Some(quality), Some(codecs)) = (
+                video["baseUrl"].as_str(),
+                video["id"].as_u64(),
+                video["codecs"].as_str(),
+            ) else {
+                continue;
+            };
+            let quality = VideoQuality::from_repr(quality as usize).ok_or(anyhow!("invalid video stream quality"))?;
+            // 从视频流的 codecs 字段中获取编码格式，此处并非精确匹配而是判断包含，比如 codecs 是 av1.42c01e，需要匹配为 av1
+            let Some(codecs) = [VideoCodecs::HEV, VideoCodecs::AVC, VideoCodecs::AV1]
+                .into_iter()
+                .find(|c| codecs.contains(c.as_ref()))
+            else {
+                // 少数情况会走到此处，如 codecs 为 dvh1.08.09、hvc1.2.4.L123.90 等，直接跳过，不影响流程
+                continue;
+            };
+            if !filter_option.codecs.contains(&codecs)
+                || quality < filter_option.video_min_quality
+                || quality > filter_option.video_max_quality
+                || (quality == VideoQuality::QualityHdr && filter_option.no_hdr)
+                || (quality == VideoQuality::QualityDolby && filter_option.no_dolby_video)
             {
                 continue;
             }
-
-            let video_codecs = video_data["codecs"].as_str().unwrap();
-            // 从视频流的 codecs 字段中获取编码格式，此处并非精确匹配而是判断包含，比如 codecs 是 av1.42c01e，需要匹配为 av1
-            let video_codecs = vec![VideoCodecs::HEV, VideoCodecs::AVC, VideoCodecs::AV1]
-                .into_iter()
-                .find(|c| video_codecs.contains(c.to_string().as_str()));
-
-            let Some(video_codecs) = video_codecs else {
-                continue;
-            };
-            if !filter_option.codecs.contains(&video_codecs) {
-                continue;
-            }
             streams.push(Stream::DashVideo {
-                url: video_stream_url,
-                quality: video_stream_quality,
-                codecs: video_codecs,
+                url: url.to_string(),
+                quality,
+                codecs,
             });
         }
-        if audios_data.is_array() {
-            for audio_data in audios_data.as_array().unwrap().iter() {
-                let audio_stream_url = audio_data["baseUrl"].as_str().unwrap().to_string();
-                let audio_stream_quality = AudioQuality::from_repr(audio_data["id"].as_u64().unwrap() as usize);
-                let Some(audio_stream_quality) = audio_stream_quality else {
+        if let Some(audios) = self.info["dash"]["audio"].as_array() {
+            for audio in audios.iter() {
+                let (Some(url), Some(quality)) = (audio["baseUrl"].as_str(), audio["id"].as_u64()) else {
                     continue;
                 };
-                if audio_stream_quality > filter_option.audio_max_quality
-                    || audio_stream_quality < filter_option.audio_min_quality
-                {
+                let quality =
+                    AudioQuality::from_repr(quality as usize).ok_or(anyhow!("invalid audio stream quality"))?;
+                if quality < filter_option.audio_min_quality || quality > filter_option.audio_max_quality {
                     continue;
                 }
                 streams.push(Stream::DashAudio {
-                    url: audio_stream_url,
-                    quality: audio_stream_quality,
+                    url: url.to_string(),
+                    quality,
                 });
             }
         }
-        if !(filter_option.no_hires || flac_data["audio"].is_null()) {
-            // 允许 hires 且存在 flac 音频流才会进来
-            let flac_stream_url = flac_data["audio"]["baseUrl"].as_str().unwrap().to_string();
-            let flac_stream_quality =
-                AudioQuality::from_repr(flac_data["audio"]["id"].as_u64().unwrap() as usize).unwrap();
-            streams.push(Stream::DashAudio {
-                url: flac_stream_url,
-                quality: flac_stream_quality,
-            });
-        }
-        if !(filter_option.no_dolby_audio || dolby_data["audio"].is_null()) {
-            // 同理，允许杜比音频且存在杜比音频流才会进来
-            let dolby_stream_data = dolby_data["audio"].as_array().and_then(|v| v.first());
-            if dolby_stream_data.is_some() {
-                let dolby_stream_data = dolby_stream_data.unwrap();
-                let dolby_stream_url = dolby_stream_data["baseUrl"].as_str().unwrap().to_string();
-                let dolby_stream_quality =
-                    AudioQuality::from_repr(dolby_stream_data["id"].as_u64().unwrap() as usize).unwrap();
+        let flac = &self.info["dash"]["flac"]["audio"];
+        if !(filter_option.no_hires || flac.is_null()) {
+            let (Some(url), Some(quality)) = (flac["baseUrl"].as_str(), flac["id"].as_u64()) else {
+                bail!("invalid flac stream");
+            };
+            let quality = AudioQuality::from_repr(quality as usize).ok_or(anyhow!("invalid flac stream quality"))?;
+            if quality >= filter_option.audio_min_quality && quality <= filter_option.audio_max_quality {
                 streams.push(Stream::DashAudio {
-                    url: dolby_stream_url,
-                    quality: dolby_stream_quality,
+                    url: url.to_string(),
+                    quality,
+                });
+            }
+        }
+        let dolby_audio = &self.info["dash"]["dolby"]["audio"][0];
+        if !(filter_option.no_dolby_audio || dolby_audio.is_null()) {
+            let (Some(url), Some(quality)) = (dolby_audio["baseUrl"].as_str(), dolby_audio["id"].as_u64()) else {
+                bail!("invalid dolby audio stream");
+            };
+            let quality =
+                AudioQuality::from_repr(quality as usize).ok_or(anyhow!("invalid dolby audio stream quality"))?;
+            if quality >= filter_option.audio_min_quality && quality <= filter_option.audio_max_quality {
+                streams.push(Stream::DashAudio {
+                    url: url.to_string(),
+                    quality,
                 });
             }
         }
@@ -250,68 +260,126 @@ impl PageAnalyzer {
         let streams = self.streams(filter_option)?;
         if self.is_flv_stream() || self.is_html5_mp4_stream() || self.is_episode_try_mp4_stream() {
             // 按照 streams 中的假设，符合这三种情况的流只有一个，直接取
-            return Ok(BestStream::Mixed(streams.into_iter().next().unwrap()));
+            return Ok(BestStream::Mixed(
+                streams.into_iter().next().ok_or(anyhow!("no stream found"))?,
+            ));
         }
-        // 将视频流和音频流拆分，分别做排序
-        let (mut video_streams, mut audio_streams): (Vec<_>, Vec<_>) =
+        let (videos, audios): (Vec<Stream>, Vec<Stream>) =
             streams.into_iter().partition(|s| matches!(s, Stream::DashVideo { .. }));
-        // 因为该处的排序与筛选选项有关，因此不能在外面实现 PartialOrd trait，只能在这里写闭包
-        video_streams.sort_by(|a, b| match (a, b) {
-            (
-                Stream::DashVideo {
-                    quality: a_quality,
-                    codecs: a_codecs,
-                    ..
-                },
-                Stream::DashVideo {
-                    quality: b_quality,
-                    codecs: b_codecs,
-                    ..
-                },
-            ) => {
-                if a_quality == &VideoQuality::QualityDolby && !filter_option.no_dolby_video {
-                    return std::cmp::Ordering::Greater;
-                }
-                if b_quality == &VideoQuality::QualityDolby && !filter_option.no_dolby_video {
-                    return std::cmp::Ordering::Less;
-                }
-                if a_quality == &VideoQuality::QualityHdr && !filter_option.no_hdr {
-                    return std::cmp::Ordering::Greater;
-                }
-                if b_quality == &VideoQuality::QualityHdr && !filter_option.no_hdr {
-                    return std::cmp::Ordering::Less;
-                }
-                if a_quality != b_quality {
-                    return a_quality.partial_cmp(b_quality).unwrap();
-                }
-                // 如果视频质量相同，按照偏好的编码优先级排序
-                filter_option
-                    .codecs
-                    .iter()
-                    .position(|c| c == b_codecs)
-                    .cmp(&filter_option.codecs.iter().position(|c| c == a_codecs))
-            }
-            _ => unreachable!(),
-        });
-        audio_streams.sort_by(|a, b| match (a, b) {
-            (Stream::DashAudio { quality: a_quality, .. }, Stream::DashAudio { quality: b_quality, .. }) => {
-                if a_quality == &AudioQuality::QualityDolby && !filter_option.no_dolby_audio {
-                    return std::cmp::Ordering::Greater;
-                }
-                if b_quality == &AudioQuality::QualityDolby && !filter_option.no_dolby_audio {
-                    return std::cmp::Ordering::Less;
-                }
-                a_quality.partial_cmp(b_quality).unwrap()
-            }
-            _ => unreachable!(),
-        });
-        if video_streams.is_empty() {
-            bail!("no video stream found");
-        }
         Ok(BestStream::VideoAudio {
-            video: video_streams.remove(video_streams.len() - 1),
-            // 音频流可能为空，因此直接使用 pop 返回 Option
-            audio: audio_streams.pop(),
+            video: Iterator::max_by(videos.into_iter(), |a, b| match (a, b) {
+                (
+                    Stream::DashVideo {
+                        quality: a_quality,
+                        codecs: a_codecs,
+                        ..
+                    },
+                    Stream::DashVideo {
+                        quality: b_quality,
+                        codecs: b_codecs,
+                        ..
+                    },
+                ) => {
+                    if a_quality != b_quality {
+                        return a_quality.partial_cmp(b_quality).unwrap();
+                    };
+                    filter_option
+                        .codecs
+                        .iter()
+                        .position(|c| c == b_codecs)
+                        .cmp(&filter_option.codecs.iter().position(|c| c == a_codecs))
+                }
+                _ => unreachable!(),
+            })
+            .ok_or(anyhow!("no video stream found"))?,
+            audio: Iterator::max_by(audios.into_iter(), |a, b| match (a, b) {
+                (Stream::DashAudio { quality: a_quality, .. }, Stream::DashAudio { quality: b_quality, .. }) => {
+                    a_quality.partial_cmp(b_quality).unwrap()
+                }
+                _ => unreachable!(),
+            }),
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::bilibili::{BiliClient, Video};
+    use crate::config::CONFIG;
+
+    #[test]
+    fn test_quality_order() {
+        assert!([
+            VideoQuality::Quality360p,
+            VideoQuality::Quality480p,
+            VideoQuality::Quality720p,
+            VideoQuality::Quality1080p,
+            VideoQuality::Quality1080pPLUS,
+            VideoQuality::Quality1080p60,
+            VideoQuality::Quality4k,
+            VideoQuality::QualityHdr,
+            VideoQuality::QualityDolby,
+            VideoQuality::Quality8k
+        ]
+        .is_sorted());
+        assert!([
+            AudioQuality::Quality64k,
+            AudioQuality::Quality132k,
+            AudioQuality::Quality192k,
+            AudioQuality::QualityDolby,
+            AudioQuality::QualityHiRES,
+        ]
+        .is_sorted());
+    }
+
+    #[ignore = "only for manual test"]
+    #[tokio::test]
+    async fn test_best_stream() {
+        let testcases = [
+            // 随便一个 8k + hires 视频
+            (
+                "BV1xRChYUE2R",
+                VideoQuality::Quality8k,
+                Some(AudioQuality::QualityHiRES),
+            ),
+            // 一个没有声音的纯视频
+            ("BV1J7411H7KQ", VideoQuality::Quality720p, None),
+            // 一个杜比全景声的演示片
+            (
+                "BV1Mm4y1P7JV",
+                VideoQuality::Quality4k,
+                Some(AudioQuality::QualityDolby),
+            ),
+        ];
+        for (bvid, video_quality, audio_quality) in testcases.into_iter() {
+            let client = BiliClient::new();
+            let video = Video::new(&client, bvid.to_owned());
+            let pages = video.get_pages().await.expect("failed to get pages");
+            let first_page = pages.into_iter().next().expect("no page found");
+            let best_stream = video
+                .get_page_analyzer(&first_page)
+                .await
+                .expect("failed to get page analyzer")
+                .best_stream(&CONFIG.filter_option)
+                .expect("failed to get best stream");
+            dbg!(bvid, &best_stream);
+            match best_stream {
+                BestStream::VideoAudio {
+                    video: Stream::DashVideo { quality, .. },
+                    audio,
+                } => {
+                    assert_eq!(quality, video_quality);
+                    assert_eq!(
+                        audio.map(|audio_stream| match audio_stream {
+                            Stream::DashAudio { quality, .. } => quality,
+                            _ => unreachable!(),
+                        }),
+                        audio_quality,
+                    );
+                }
+                _ => unreachable!(),
+            }
+        }
+    }
+}

crates/bili_sync/src/bilibili/client.rs

@@ -1,10 +1,13 @@
 use std::sync::Arc;
+use std::time::Duration;
 
 use anyhow::{bail, Result};
+use leaky_bucket::RateLimiter;
 use reqwest::{header, Method};
 
+use crate::bilibili::credential::WbiImg;
 use crate::bilibili::Credential;
-use crate::config::CONFIG;
+use crate::config::{RateLimit, CONFIG};
 
 // 一个对 reqwest::Client 的简单封装，用于 Bilibili 请求
 #[derive(Clone)]
@@ -60,15 +63,32 @@ impl Default for Client {
 
 pub struct BiliClient {
     pub client: Client,
+    limiter: Option<RateLimiter>,
 }
 
 impl BiliClient {
     pub fn new() -> Self {
         let client = Client::new();
-        Self { client }
+        let limiter = CONFIG
+            .concurrent_limit
+            .rate_limit
+            .as_ref()
+            .map(|RateLimit { limit, duration }| {
+                RateLimiter::builder()
+                    .initial(*limit)
+                    .refill(*limit)
+                    .max(*limit)
+                    .interval(Duration::from_millis(*duration))
+                    .build()
+            });
+        Self { client, limiter }
     }
 
-    pub fn request(&self, method: Method, url: &str) -> reqwest::RequestBuilder {
+    /// 获取一个预构建的请求，通过该方法获取请求时会检查并等待速率限制
+    pub async fn request(&self, method: Method, url: &str) -> reqwest::RequestBuilder {
+        if let Some(limiter) = &self.limiter {
+            limiter.acquire_one().await;
+        }
         let credential = CONFIG.credential.load();
         self.client.request(method, url, credential.as_deref())
     }
@@ -86,12 +106,12 @@ impl BiliClient {
         CONFIG.save()
     }
 
-    /// 检查凭据是否已设置且有效
-    pub async fn is_login(&self) -> Result<()> {
+    /// 获取 wbi img，用于生成请求签名
+    pub async fn wbi_img(&self) -> Result<WbiImg> {
         let credential = CONFIG.credential.load();
         let Some(credential) = credential.as_deref() else {
             bail!("no credential found");
         };
-        credential.is_login(&self.client).await
+        credential.wbi_img(&self.client).await
     }
 }

crates/bili_sync/src/bilibili/collection.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 use std::fmt::{Display, Formatter};
 
 use anyhow::Result;
@@ -9,7 +7,8 @@ use reqwest::Method;
 use serde::Deserialize;
 use serde_json::Value;
 
-use crate::bilibili::{BiliClient, Validate, VideoInfo};
+use crate::bilibili::credential::encoded_query;
+use crate::bilibili::{BiliClient, Validate, VideoInfo, MIXIN_KEY};
 
 #[derive(PartialEq, Eq, Hash, Clone, Debug)]
 pub enum CollectionType {
@@ -108,12 +107,9 @@ impl<'a> Collection<'a> {
     }
 
     async fn get_series_info(&self) -> Result<Value> {
-        assert!(
-            self.collection.collection_type == CollectionType::Series,
-            "collection type is not series"
-        );
         self.client
             .request(Method::GET, "https://api.bilibili.com/x/series/series")
+            .await
             .query(&[("series_id", self.collection.sid.as_str())])
             .send()
             .await?
@@ -128,28 +124,35 @@ impl<'a> Collection<'a> {
         let (url, query) = match self.collection.collection_type {
             CollectionType::Series => (
                 "https://api.bilibili.com/x/series/archives",
-                vec![
-                    ("mid", self.collection.mid.as_str()),
-                    ("series_id", self.collection.sid.as_str()),
-                    ("only_normal", "true"),
-                    ("sort", "desc"),
-                    ("pn", page.as_str()),
-                    ("ps", "30"),
-                ],
+                encoded_query(
+                    vec![
+                        ("mid", self.collection.mid.as_str()),
+                        ("series_id", self.collection.sid.as_str()),
+                        ("only_normal", "true"),
+                        ("sort", "desc"),
+                        ("pn", page.as_str()),
+                        ("ps", "30"),
+                    ],
+                    MIXIN_KEY.load().as_deref().map(|x| x.as_str()),
+                ),
             ),
             CollectionType::Season => (
                 "https://api.bilibili.com/x/polymer/web-space/seasons_archives_list",
-                vec![
-                    ("mid", self.collection.mid.as_str()),
-                    ("season_id", self.collection.sid.as_str()),
-                    ("sort_reverse", "true"),
-                    ("page_num", page.as_str()),
-                    ("page_size", "30"),
-                ],
+                encoded_query(
+                    vec![
+                        ("mid", self.collection.mid.as_str()),
+                        ("season_id", self.collection.sid.as_str()),
+                        ("sort_reverse", "true"),
+                        ("page_num", page.as_str()),
+                        ("page_size", "30"),
+                    ],
+                    MIXIN_KEY.load().as_deref().map(|x| x.as_str()),
+                ),
             ),
         };
         self.client
             .request(Method::GET, url)
+            .await
             .query(&query)
             .send()
             .await?
@@ -181,7 +184,7 @@ impl<'a> Collection<'a> {
                         break;
                     },
                 };
-                for video_info in videos_info.into_iter(){
+                for video_info in videos_info{
                     yield video_info;
                 }
                 let fields = match self.collection.collection_type{

crates/bili_sync/src/bilibili/credential.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::collections::HashSet;
 
 use anyhow::{anyhow, bail, Result};
@@ -11,6 +12,12 @@ use serde::{Deserialize, Serialize};
 
 use crate::bilibili::{Client, Validate};
 
+const MIXIN_KEY_ENC_TAB: [usize; 64] = [
+    46, 47, 18, 2, 53, 8, 23, 32, 15, 50, 10, 31, 58, 3, 45, 35, 27, 43, 5, 49, 33, 9, 42, 19, 29, 28, 14, 39, 12, 38,
+    41, 13, 37, 48, 7, 16, 24, 55, 40, 61, 26, 17, 0, 1, 60, 51, 30, 4, 22, 25, 54, 21, 56, 59, 6, 63, 57, 62, 11, 36,
+    20, 34, 44, 52,
+];
+
 #[derive(Default, Debug, Clone, Serialize, Deserialize)]
 pub struct Credential {
     pub sessdata: String,
@@ -20,7 +27,39 @@ pub struct Credential {
     pub ac_time_value: String,
 }
 
+#[derive(Debug, Deserialize)]
+pub struct WbiImg {
+    img_url: String,
+    sub_url: String,
+}
+
+impl From<WbiImg> for Option<String> {
+    /// 尝试将 WbiImg 转换成 mixin_key
+    fn from(value: WbiImg) -> Self {
+        let key = match (
+            get_filename(value.img_url.as_str()),
+            get_filename(value.sub_url.as_str()),
+        ) {
+            (Some(img_key), Some(sub_key)) => img_key.to_string() + sub_key,
+            _ => return None,
+        };
+        let key = key.as_bytes();
+        Some(MIXIN_KEY_ENC_TAB.iter().take(32).map(|&x| key[x] as char).collect())
+    }
+}
+
 impl Credential {
+    pub async fn wbi_img(&self, client: &Client) -> Result<WbiImg> {
+        let mut res = client
+            .request(Method::GET, "https://api.bilibili.com/x/web-interface/nav", Some(self))
+            .send()
+            .await?
+            .json::<serde_json::Value>()
+            .await?
+            .validate()?;
+        Ok(serde_json::from_value(res["data"]["wbi_img"].take())?)
+    }
+
     /// 检查凭据是否有效
     pub async fn need_refresh(&self, client: &Client) -> Result<bool> {
         let res = client
@@ -38,24 +77,6 @@ impl Credential {
         res["data"]["refresh"].as_bool().ok_or(anyhow!("check refresh failed"))
     }
 
-    /// 需要使用一个需要鉴权的接口来检查是否登录
-    /// 此处使用查看用户状态数的接口，该接口返回内容少，请求成本低
-    pub async fn is_login(&self, client: &Client) -> Result<()> {
-        client
-            .request(
-                Method::GET,
-                "https://api.bilibili.com/x/web-interface/nav/stat",
-                Some(self),
-            )
-            .send()
-            .await?
-            .error_for_status()?
-            .json::<serde_json::Value>()
-            .await?
-            .validate()?;
-        Ok(())
-    }
-
     pub async fn refresh(&self, client: &Client) -> Result<Self> {
         let correspond_path = Self::get_correspond_path();
         let csrf = self.get_refresh_csrf(client, correspond_path).await?;
@@ -181,6 +202,49 @@ fn regex_find(pattern: &str, doc: &str) -> Result<String> {
         .to_string())
 }
 
+fn get_filename(url: &str) -> Option<&str> {
+    url.rsplit_once('/')
+        .and_then(|(_, s)| s.rsplit_once('.'))
+        .map(|(s, _)| s)
+}
+
+pub fn encoded_query<'a>(
+    params: Vec<(&'a str, impl Into<Cow<'a, str>>)>,
+    mixin_key: Option<&str>,
+) -> Vec<(&'a str, Cow<'a, str>)> {
+    match mixin_key {
+        Some(key) => _encoded_query(params, key, chrono::Local::now().timestamp().to_string()),
+        None => params.into_iter().map(|(k, v)| (k, v.into())).collect(),
+    }
+}
+
+#[inline]
+fn _encoded_query<'a>(
+    params: Vec<(&'a str, impl Into<Cow<'a, str>>)>,
+    mixin_key: &str,
+    timestamp: String,
+) -> Vec<(&'a str, Cow<'a, str>)> {
+    let mut params: Vec<(&'a str, Cow<'a, str>)> = params
+        .into_iter()
+        .map(|(k, v)| {
+            (
+                k,
+                // FIXME: 总感觉这里不太好，即使 v 是 &str 也会被转换成 String
+                v.into()
+                    .chars()
+                    .filter(|&x| !"!'()*".contains(x))
+                    .collect::<String>()
+                    .into(),
+            )
+        })
+        .collect();
+    params.push(("wts", timestamp.into()));
+    params.sort_by(|a, b| a.0.cmp(b.0));
+    let query = serde_urlencoded::to_string(&params).unwrap().replace('+', "%20");
+    params.push(("w_rid", format!("{:x}", md5::compute(query.clone() + mixin_key)).into()));
+    params
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -199,4 +263,42 @@ mod tests {
             "b0cc8411ded2f9db2cff2edb3123acac",
         );
     }
+
+    #[test]
+    fn test_encode_query() {
+        let query = vec![
+            ("bar", "五一四".to_string()),
+            ("baz", "1919810".to_string()),
+            ("foo", "one one four".to_string()),
+        ];
+        assert_eq!(
+            serde_urlencoded::to_string(query).unwrap().replace('+', "%20"),
+            "bar=%E4%BA%94%E4%B8%80%E5%9B%9B&baz=1919810&foo=one%20one%20four"
+        );
+    }
+
+    #[test]
+    fn test_wbi_key() {
+        let key = WbiImg {
+            img_url: "https://i0.hdslb.com/bfs/wbi/7cd084941338484aae1ad9425b84077c.png".to_string(),
+            sub_url: "https://i0.hdslb.com/bfs/wbi/4932caff0ff746eab6f01bf08b70ac45.png".to_string(),
+        };
+        let key = Option::<String>::from(key).expect("fail to convert key");
+        assert_eq!(key.as_str(), "ea1db124af3c7062474693fa704f4ff8");
+        assert_eq!(
+            dbg!(_encoded_query(
+                vec![("foo", "114"), ("bar", "514"), ("zab", "1919810")],
+                key.as_str(),
+                "1702204169".to_string(),
+            )),
+            // 上面产生的结果全是 Cow::Owned，但 eq 只会比较值，这样写比较方便
+            vec![
+                ("bar", Cow::Borrowed("514")),
+                ("foo", Cow::Borrowed("114")),
+                ("wts", Cow::Borrowed("1702204169")),
+                ("zab", Cow::Borrowed("1919810")),
+                ("w_rid", Cow::Borrowed("8f6f2b5b3d485fe1886cec6a0be8c5d4")),
+            ]
+        );
+    }
 }

crates/bili_sync/src/bilibili/favorite_list.rs

@@ -16,8 +16,8 @@ pub struct FavoriteListInfo {
 }
 
 #[derive(Debug, serde::Deserialize)]
-pub struct Upper {
-    pub mid: i64,
+pub struct Upper<T> {
+    pub mid: T,
     pub name: String,
     pub face: String,
 }
@@ -30,6 +30,7 @@ impl<'a> FavoriteList<'a> {
         let mut res = self
             .client
             .request(reqwest::Method::GET, "https://api.bilibili.com/x/v3/fav/folder/info")
+            .await
             .query(&[("media_id", &self.fid)])
             .send()
             .await?
@@ -43,6 +44,7 @@ impl<'a> FavoriteList<'a> {
     async fn get_videos(&self, page: u32) -> Result<Value> {
         self.client
             .request(reqwest::Method::GET, "https://api.bilibili.com/x/v3/fav/resource/list")
+            .await
             .query(&[
                 ("media_id", self.fid.as_str()),
                 ("pn", &page.to_string()),
@@ -82,7 +84,7 @@ impl<'a> FavoriteList<'a> {
                         break;
                     },
                 };
-                for video_info in videos_info.into_iter(){
+                for video_info in videos_info{
                     yield video_info;
                 }
                 if videos["data"]["has_more"].is_boolean() && videos["data"]["has_more"].as_bool().unwrap(){

crates/bili_sync/src/bilibili/mod.rs

@@ -1,5 +1,8 @@
+use std::sync::Arc;
+
 pub use analyzer::{BestStream, FilterOption};
 use anyhow::{bail, Result};
+use arc_swap::ArcSwapOption;
 use chrono::serde::ts_seconds;
 use chrono::{DateTime, Utc};
 pub use client::{BiliClient, Client};
@@ -9,7 +12,10 @@ pub use danmaku::DanmakuOption;
 pub use error::BiliError;
 pub use favorite_list::FavoriteList;
 use favorite_list::Upper;
+use once_cell::sync::Lazy;
+pub use submission::Submission;
 pub use video::{Dimension, PageInfo, Video};
+pub use watch_later::WatchLater;
 
 mod analyzer;
 mod client;
@@ -18,7 +24,16 @@ mod credential;
 mod danmaku;
 mod error;
 mod favorite_list;
+mod submission;
 mod video;
+mod watch_later;
+
+static MIXIN_KEY: Lazy<ArcSwapOption<String>> = Lazy::new(Default::default);
+
+#[inline]
+pub(crate) fn set_global_mixin_key(key: String) {
+    MIXIN_KEY.store(Some(Arc::new(key)));
+}
 
 pub(crate) trait Validate {
     type Output;
@@ -56,7 +71,7 @@ pub enum VideoInfo {
         #[serde(rename = "pic")]
         cover: String,
         #[serde(rename = "owner")]
-        upper: Upper,
+        upper: Upper<i64>,
         #[serde(with = "ts_seconds")]
         ctime: DateTime<Utc>,
         #[serde(rename = "pubdate", with = "ts_seconds")]
@@ -72,7 +87,7 @@ pub enum VideoInfo {
         bvid: String,
         intro: String,
         cover: String,
-        upper: Upper,
+        upper: Upper<i64>,
         #[serde(with = "ts_seconds")]
         ctime: DateTime<Utc>,
         #[serde(with = "ts_seconds")]
@@ -81,6 +96,24 @@ pub enum VideoInfo {
         pubtime: DateTime<Utc>,
         attr: i32,
     },
+    /// 从稍后再看中获取的视频信息
+    WatchLater {
+        title: String,
+        bvid: String,
+        #[serde(rename = "desc")]
+        intro: String,
+        #[serde(rename = "pic")]
+        cover: String,
+        #[serde(rename = "owner")]
+        upper: Upper<i64>,
+        #[serde(with = "ts_seconds")]
+        ctime: DateTime<Utc>,
+        #[serde(rename = "add_at", with = "ts_seconds")]
+        fav_time: DateTime<Utc>,
+        #[serde(rename = "pubdate", with = "ts_seconds")]
+        pubtime: DateTime<Utc>,
+        state: i32,
+    },
     /// 从视频列表中获取的视频信息
     Simple {
         bvid: String,
@@ -91,4 +124,57 @@ pub enum VideoInfo {
         #[serde(rename = "pubdate", with = "ts_seconds")]
         pubtime: DateTime<Utc>,
     },
+    Submission {
+        title: String,
+        bvid: String,
+        #[serde(rename = "description")]
+        intro: String,
+        #[serde(rename = "pic")]
+        cover: String,
+        #[serde(rename = "created", with = "ts_seconds")]
+        ctime: DateTime<Utc>,
+    },
+}
+
+#[cfg(test)]
+mod tests {
+    use futures::{pin_mut, StreamExt};
+
+    use super::*;
+    use crate::utils::init_logger;
+
+    #[ignore = "only for manual test"]
+    #[tokio::test]
+    async fn test_video_info_type() {
+        init_logger("None,bili_sync=debug");
+        let bili_client = BiliClient::new();
+        // 请求 UP 主视频必须要获取 mixin key，使用 key 计算请求参数的签名，否则直接提示权限不足返回空
+        let Ok(Some(mixin_key)) = bili_client.wbi_img().await.map(|wbi_img| wbi_img.into()) else {
+            panic!("获取 mixin key 失败");
+        };
+        set_global_mixin_key(mixin_key);
+        let video = Video::new(&bili_client, "BV1Z54y1C7ZB".to_string());
+        assert!(matches!(video.get_view_info().await, Ok(VideoInfo::View { .. })));
+        let collection_item = CollectionItem {
+            mid: "521722088".to_string(),
+            sid: "387214".to_string(),
+            collection_type: CollectionType::Series,
+        };
+        let collection = Collection::new(&bili_client, &collection_item);
+        let stream = collection.into_simple_video_stream();
+        pin_mut!(stream);
+        assert!(matches!(stream.next().await, Some(VideoInfo::Simple { .. })));
+        let favorite = FavoriteList::new(&bili_client, "3084505258".to_string());
+        let stream = favorite.into_video_stream();
+        pin_mut!(stream);
+        assert!(matches!(stream.next().await, Some(VideoInfo::Detail { .. })));
+        let watch_later = WatchLater::new(&bili_client);
+        let stream = watch_later.into_video_stream();
+        pin_mut!(stream);
+        assert!(matches!(stream.next().await, Some(VideoInfo::WatchLater { .. })));
+        let submission = Submission::new(&bili_client, "956761".to_string());
+        let stream = submission.into_video_stream();
+        pin_mut!(stream);
+        assert!(matches!(stream.next().await, Some(VideoInfo::Submission { .. })));
+    }
 }

crates/bili_sync/src/bilibili/submission.rs

@@ -0,0 +1,93 @@
+use anyhow::Result;
+use arc_swap::access::Access;
+use async_stream::stream;
+use futures::Stream;
+use reqwest::Method;
+use serde_json::Value;
+
+use crate::bilibili::credential::encoded_query;
+use crate::bilibili::favorite_list::Upper;
+use crate::bilibili::{BiliClient, Validate, VideoInfo, MIXIN_KEY};
+pub struct Submission<'a> {
+    client: &'a BiliClient,
+    upper_id: String,
+}
+
+impl<'a> Submission<'a> {
+    pub fn new(client: &'a BiliClient, upper_id: String) -> Self {
+        Self { client, upper_id }
+    }
+
+    pub async fn get_info(&self) -> Result<Upper<String>> {
+        let mut res = self
+            .client
+            .request(Method::GET, "https://api.bilibili.com/x/web-interface/card")
+            .await
+            .query(&[("mid", self.upper_id.as_str())])
+            .send()
+            .await?
+            .error_for_status()?
+            .json::<serde_json::Value>()
+            .await?
+            .validate()?;
+        Ok(serde_json::from_value(res["data"]["card"].take())?)
+    }
+
+    async fn get_videos(&self, page: i32) -> Result<Value> {
+        self.client
+            .request(Method::GET, "https://api.bilibili.com/x/space/wbi/arc/search")
+            .await
+            .query(&encoded_query(
+                vec![
+                    ("mid", self.upper_id.clone()),
+                    ("order", "pubdate".to_string()),
+                    ("order_avoided", "true".to_string()),
+                    ("platform", "web".to_string()),
+                    ("web_location", "1550101".to_string()),
+                    ("pn", page.to_string()),
+                    ("ps", "30".to_string()),
+                ],
+                MIXIN_KEY.load().as_deref().map(|x| x.as_str()),
+            ))
+            .send()
+            .await?
+            .error_for_status()?
+            .json::<serde_json::Value>()
+            .await?
+            .validate()
+    }
+
+    pub fn into_video_stream(self) -> impl Stream<Item = VideoInfo> + 'a {
+        stream! {
+            let mut page = 1;
+            loop {
+                let mut videos = match self.get_videos(page).await {
+                    Ok(v) => v,
+                    Err(e) => {
+                        error!("failed to get videos of upper {} page {}: {}", self.upper_id, page, e);
+                        break;
+                    },
+                };
+                if !videos["data"]["list"]["vlist"].is_array() {
+                    warn!("no medias found in upper {} page {}", self.upper_id, page);
+                    break;
+                }
+                let videos_info = match serde_json::from_value::<Vec<VideoInfo>>(videos["data"]["list"]["vlist"].take()) {
+                    Ok(v) => v,
+                    Err(e) => {
+                        error!("failed to parse videos of upper {} page {}: {}", self.upper_id, page, e);
+                        break;
+                    },
+                };
+                for video_info in videos_info{
+                    yield video_info;
+                }
+                if videos["data"]["page"]["count"].is_i64() && videos["data"]["page"]["count"].as_i64().unwrap() > (page * 30) as i64 {
+                    page += 1;
+                    continue;
+                }
+                break;
+            }
+        }
+    }
+}

crates/bili_sync/src/bilibili/video.rs

@@ -6,8 +6,9 @@ use reqwest::Method;
 
 use crate::bilibili::analyzer::PageAnalyzer;
 use crate::bilibili::client::BiliClient;
+use crate::bilibili::credential::encoded_query;
 use crate::bilibili::danmaku::{DanmakuElem, DanmakuWriter, DmSegMobileReply};
-use crate::bilibili::{Validate, VideoInfo};
+use crate::bilibili::{Validate, VideoInfo, MIXIN_KEY};
 
 static MASK_CODE: u64 = 2251799813685247;
 static XOR_CODE: u64 = 23442827791579;
@@ -61,12 +62,12 @@ impl<'a> Video<'a> {
         Self { client, aid, bvid }
     }
 
-    #[allow(dead_code)]
     /// 直接调用视频信息接口获取详细的视频信息
     pub async fn get_view_info(&self) -> Result<VideoInfo> {
         let mut res = self
             .client
             .request(Method::GET, "https://api.bilibili.com/x/web-interface/view")
+            .await
             .query(&[("aid", &self.aid), ("bvid", &self.bvid)])
             .send()
             .await?
@@ -81,6 +82,7 @@ impl<'a> Video<'a> {
         let mut res = self
             .client
             .request(Method::GET, "https://api.bilibili.com/x/player/pagelist")
+            .await
             .query(&[("aid", &self.aid), ("bvid", &self.bvid)])
             .send()
             .await?
@@ -95,6 +97,7 @@ impl<'a> Video<'a> {
         let mut res = self
             .client
             .request(Method::GET, "https://api.bilibili.com/x/web-interface/view/detail/tag")
+            .await
             .query(&[("aid", &self.aid), ("bvid", &self.bvid)])
             .send()
             .await?
@@ -120,13 +123,14 @@ impl<'a> Video<'a> {
         let mut res = self
             .client
             .request(Method::GET, "http://api.bilibili.com/x/v2/dm/web/seg.so")
+            .await
             .query(&[("type", 1), ("oid", page.cid), ("segment_index", segment_idx)])
             .send()
             .await?
             .error_for_status()?;
         let headers = std::mem::take(res.headers_mut());
         let content_type = headers.get("content-type");
-        if !content_type.is_some_and(|v| v == "application/octet-stream") {
+        if content_type.is_none_or(|v| v != "application/octet-stream") {
             bail!(
                 "unexpected content type: {:?}, body: {:?}",
                 content_type,
@@ -140,14 +144,18 @@ impl<'a> Video<'a> {
         let mut res = self
             .client
             .request(Method::GET, "https://api.bilibili.com/x/player/wbi/playurl")
-            .query(&[
-                ("avid", self.aid.as_str()),
-                ("cid", page.cid.to_string().as_str()),
-                ("qn", "127"),
-                ("otype", "json"),
-                ("fnval", "4048"),
-                ("fourk", "1"),
-            ])
+            .await
+            .query(&encoded_query(
+                vec![
+                    ("avid", self.aid.as_str()),
+                    ("cid", page.cid.to_string().as_str()),
+                    ("qn", "127"),
+                    ("otype", "json"),
+                    ("fnval", "4048"),
+                    ("fourk", "1"),
+                ],
+                MIXIN_KEY.load().as_deref().map(|x| x.as_str()),
+            ))
             .send()
             .await?
             .error_for_status()?

crates/bili_sync/src/bilibili/watch_later.rs

@@ -0,0 +1,49 @@
+use anyhow::Result;
+use async_stream::stream;
+use futures::Stream;
+use serde_json::Value;
+
+use crate::bilibili::{BiliClient, Validate, VideoInfo};
+pub struct WatchLater<'a> {
+    client: &'a BiliClient,
+}
+
+impl<'a> WatchLater<'a> {
+    pub fn new(client: &'a BiliClient) -> Self {
+        Self { client }
+    }
+
+    async fn get_videos(&self) -> Result<Value> {
+        self.client
+            .request(reqwest::Method::GET, "https://api.bilibili.com/x/v2/history/toview")
+            .await
+            .send()
+            .await?
+            .error_for_status()?
+            .json::<serde_json::Value>()
+            .await?
+            .validate()
+    }
+
+    pub fn into_video_stream(self) -> impl Stream<Item = VideoInfo> + 'a {
+        stream! {
+            let Ok(mut videos) = self.get_videos().await else {
+                error!("Failed to get watch later list");
+                return;
+            };
+            if !videos["data"]["list"].is_array() {
+                error!("Watch later list is not an array");
+            }
+            let videos_info = match serde_json::from_value::<Vec<VideoInfo>>(videos["data"]["list"].take()) {
+                Ok(v) => v,
+                Err(e) => {
+                    error!("Failed to parse watch later list: {}", e);
+                    return;
+                }
+            };
+            for video in videos_info {
+                yield video;
+            }
+        }
+    }
+}

crates/bili_sync/src/config.rs

@@ -1,250 +0,0 @@
-use std::borrow::Cow;
-use std::collections::HashMap;
-use std::path::PathBuf;
-use std::sync::Arc;
-
-use anyhow::Result;
-use arc_swap::ArcSwapOption;
-use handlebars::handlebars_helper;
-use once_cell::sync::Lazy;
-use serde::de::{Deserializer, MapAccess, Visitor};
-use serde::ser::SerializeMap;
-use serde::{Deserialize, Serialize};
-
-use crate::bilibili::{CollectionItem, CollectionType, Credential, DanmakuOption, FilterOption};
-
-pub static TEMPLATE: Lazy<handlebars::Handlebars> = Lazy::new(|| {
-    let mut handlebars = handlebars::Handlebars::new();
-    handlebars_helper!(truncate: |s: String, len: usize| {
-        if s.chars().count() > len {
-            s.chars().take(len).collect::<String>()
-        } else {
-            s.to_string()
-        }
-    });
-    handlebars.register_helper("truncate", Box::new(truncate));
-    handlebars
-        .register_template_string("video", &CONFIG.video_name)
-        .unwrap();
-    handlebars.register_template_string("page", &CONFIG.page_name).unwrap();
-    handlebars
-});
-
-pub static CONFIG: Lazy<Config> = Lazy::new(|| {
-    let config = Config::load().unwrap_or_else(|err| {
-        if err
-            .downcast_ref::<std::io::Error>()
-            .map_or(true, |e| e.kind() != std::io::ErrorKind::NotFound)
-        {
-            panic!("加载配置文件失败，错误为： {err}");
-        }
-        warn!("配置文件不存在，使用默认配置...");
-        Config::default()
-    });
-    // 放到外面，确保新的配置项被保存
-    info!("配置加载完毕，覆盖刷新原有配置");
-    config.save().unwrap();
-    // 检查配置文件内容
-    info!("校验配置文件内容...");
-    config.check();
-    config
-});
-
-pub static ARGS: Lazy<Args> = Lazy::new(Args::parse);
-
-pub static CONFIG_DIR: Lazy<PathBuf> =
-    Lazy::new(|| dirs::config_dir().expect("No config path found").join("bili-sync"));
-
-#[derive(Serialize, Deserialize)]
-pub struct Config {
-    pub credential: ArcSwapOption<Credential>,
-    pub filter_option: FilterOption,
-    #[serde(default)]
-    pub danmaku_option: DanmakuOption,
-    pub favorite_list: HashMap<String, PathBuf>,
-    #[serde(
-        default,
-        serialize_with = "serialize_collection_list",
-        deserialize_with = "deserialize_collection_list"
-    )]
-    pub collection_list: HashMap<CollectionItem, PathBuf>,
-    pub video_name: Cow<'static, str>,
-    pub page_name: Cow<'static, str>,
-    pub interval: u64,
-    pub upper_path: PathBuf,
-    #[serde(default)]
-    pub nfo_time_type: NFOTimeType,
-}
-
-#[derive(Serialize, Deserialize, Default)]
-#[serde(rename_all = "lowercase")]
-pub enum NFOTimeType {
-    #[default]
-    FavTime,
-    PubTime,
-}
-
-impl Default for Config {
-    fn default() -> Self {
-        Self {
-            credential: ArcSwapOption::from(Some(Arc::new(Credential::default()))),
-            filter_option: FilterOption::default(),
-            danmaku_option: DanmakuOption::default(),
-            favorite_list: HashMap::new(),
-            collection_list: HashMap::new(),
-            video_name: Cow::Borrowed("{{title}}"),
-            page_name: Cow::Borrowed("{{bvid}}"),
-            interval: 1200,
-            upper_path: CONFIG_DIR.join("upper_face"),
-            nfo_time_type: NFOTimeType::FavTime,
-        }
-    }
-}
-
-impl Config {
-    /// 简单的预检查
-    pub fn check(&self) {
-        let mut ok = true;
-        if self.favorite_list.is_empty() && self.collection_list.is_empty() {
-            ok = false;
-            error!("未设置需监听的收藏夹或视频合集，程序空转没有意义");
-        }
-        for path in self.favorite_list.values() {
-            if !path.is_absolute() {
-                ok = false;
-                error!("收藏夹保存的路径应为绝对路径，检测到: {}", path.display());
-            }
-        }
-        if !self.upper_path.is_absolute() {
-            ok = false;
-            error!("up 主头像保存的路径应为绝对路径");
-        }
-        if self.video_name.is_empty() {
-            ok = false;
-            error!("未设置 video_name 模板");
-        }
-        if self.page_name.is_empty() {
-            ok = false;
-            error!("未设置 page_name 模板");
-        }
-        let credential = self.credential.load();
-        match credential.as_deref() {
-            Some(credential) => {
-                if credential.sessdata.is_empty()
-                    || credential.bili_jct.is_empty()
-                    || credential.buvid3.is_empty()
-                    || credential.dedeuserid.is_empty()
-                    || credential.ac_time_value.is_empty()
-                {
-                    ok = false;
-                    error!("Credential 信息不完整，请确保填写完整");
-                }
-            }
-            None => {
-                ok = false;
-                error!("未设置 Credential 信息");
-            }
-        }
-
-        if !ok {
-            panic!(
-                "位于 {} 的配置文件不合法，请参考提示信息修复后继续运行",
-                CONFIG_DIR.join("config.toml").display()
-            );
-        }
-    }
-
-    fn load() -> Result<Self> {
-        let config_path = CONFIG_DIR.join("config.toml");
-        let config_content = std::fs::read_to_string(config_path)?;
-        Ok(toml::from_str(&config_content)?)
-    }
-
-    pub fn save(&self) -> Result<()> {
-        let config_path = CONFIG_DIR.join("config.toml");
-        std::fs::create_dir_all(&*CONFIG_DIR)?;
-        std::fs::write(config_path, toml::to_string_pretty(self)?)?;
-        Ok(())
-    }
-}
-
-fn serialize_collection_list<S>(
-    collection_list: &HashMap<CollectionItem, PathBuf>,
-    serializer: S,
-) -> Result<S::Ok, S::Error>
-where
-    S: serde::Serializer,
-{
-    let mut map = serializer.serialize_map(Some(collection_list.len()))?;
-    for (k, v) in collection_list {
-        let prefix = match k.collection_type {
-            CollectionType::Series => "series",
-            CollectionType::Season => "season",
-        };
-        map.serialize_entry(&[prefix, &k.mid, &k.sid].join(":"), v)?;
-    }
-    map.end()
-}
-
-fn deserialize_collection_list<'de, D>(deserializer: D) -> Result<HashMap<CollectionItem, PathBuf>, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    struct CollectionListVisitor;
-
-    impl<'de> Visitor<'de> for CollectionListVisitor {
-        type Value = HashMap<CollectionItem, PathBuf>;
-
-        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-            formatter.write_str("a map of collection list")
-        }
-
-        fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
-        where
-            A: MapAccess<'de>,
-        {
-            let mut collection_list = HashMap::new();
-            while let Some((key, value)) = map.next_entry::<String, PathBuf>()? {
-                let collection_item = match key.split(':').collect::<Vec<&str>>().as_slice() {
-                    [prefix, mid, sid] => {
-                        let collection_type = match *prefix {
-                            "series" => CollectionType::Series,
-                            "season" => CollectionType::Season,
-                            _ => {
-                                return Err(serde::de::Error::custom(
-                                    "invalid collection type, should be series or season",
-                                ))
-                            }
-                        };
-                        CollectionItem {
-                            mid: mid.to_string(),
-                            sid: sid.to_string(),
-                            collection_type,
-                        }
-                    }
-                    _ => {
-                        return Err(serde::de::Error::custom(
-                            "invalid collection key, should be series:mid:sid or season:mid:sid",
-                        ))
-                    }
-                };
-                collection_list.insert(collection_item, value);
-            }
-            Ok(collection_list)
-        }
-    }
-
-    deserializer.deserialize_map(CollectionListVisitor)
-}
-
-use clap::Parser;
-
-#[derive(Parser)]
-#[command(version, about, long_about = None)]
-pub struct Args {
-    #[arg(short, long, env = "SCAN_ONLY")]
-    pub scan_only: bool,
-
-    #[arg(short, long, default_value = "None,bili_sync=info", env = "RUST_LOG")]
-    pub log_level: String,
-}

crates/bili_sync/src/config/clap.rs

@@ -0,0 +1,11 @@
+use clap::Parser;
+
+#[derive(Parser)]
+#[command(version, about, long_about = None)]
+pub struct Args {
+    #[arg(short, long, env = "SCAN_ONLY")]
+    pub scan_only: bool,
+
+    #[arg(short, long, default_value = "None,bili_sync=info", env = "RUST_LOG")]
+    pub log_level: String,
+}

crates/bili_sync/src/config/global.rs

@@ -0,0 +1,84 @@
+use std::path::PathBuf;
+
+use clap::Parser;
+use handlebars::handlebars_helper;
+use once_cell::sync::Lazy;
+
+use crate::config::clap::Args;
+use crate::config::item::PathSafeTemplate;
+use crate::config::Config;
+
+/// 全局的 CONFIG，可以从中读取配置信息
+pub static CONFIG: Lazy<Config> = Lazy::new(load_config);
+
+/// 全局的 TEMPLATE，用来渲染 video_name 和 page_name 模板
+pub static TEMPLATE: Lazy<handlebars::Handlebars> = Lazy::new(|| {
+    let mut handlebars = handlebars::Handlebars::new();
+    handlebars_helper!(truncate: |s: String, len: usize| {
+        if s.chars().count() > len {
+            s.chars().take(len).collect::<String>()
+        } else {
+            s.to_string()
+        }
+    });
+    handlebars.register_helper("truncate", Box::new(truncate));
+    handlebars.path_safe_register("video", &CONFIG.video_name).unwrap();
+    handlebars.path_safe_register("page", &CONFIG.page_name).unwrap();
+    handlebars
+});
+
+/// 全局的 ARGS，用来解析命令行参数
+pub static ARGS: Lazy<Args> = Lazy::new(Args::parse);
+
+/// 全局的 CONFIG_DIR，表示配置文件夹的路径
+pub static CONFIG_DIR: Lazy<PathBuf> =
+    Lazy::new(|| dirs::config_dir().expect("No config path found").join("bili-sync"));
+
+#[cfg(not(test))]
+#[inline]
+fn load_config() -> Config {
+    let config = Config::load().unwrap_or_else(|err| {
+        if err
+            .downcast_ref::<std::io::Error>()
+            .is_none_or(|e| e.kind() != std::io::ErrorKind::NotFound)
+        {
+            panic!("加载配置文件失败，错误为： {err}");
+        }
+        warn!("配置文件不存在，使用默认配置...");
+        Config::default()
+    });
+    // 放到外面，确保新的配置项被保存
+    info!("配置加载完毕，覆盖刷新原有配置");
+    config.save().unwrap();
+    // 检查配置文件内容
+    info!("校验配置文件内容...");
+    config.check();
+    config
+}
+
+#[cfg(test)]
+#[inline]
+fn load_config() -> Config {
+    let credential = match (
+        std::env::var("TEST_SESSDATA"),
+        std::env::var("TEST_BILI_JCT"),
+        std::env::var("TEST_BUVID3"),
+        std::env::var("TEST_DEDEUSERID"),
+        std::env::var("TEST_AC_TIME_VALUE"),
+    ) {
+        (Ok(sessdata), Ok(bili_jct), Ok(buvid3), Ok(dedeuserid), Ok(ac_time_value)) => {
+            Some(std::sync::Arc::new(crate::bilibili::Credential {
+                sessdata,
+                bili_jct,
+                buvid3,
+                dedeuserid,
+                ac_time_value,
+            }))
+        }
+        _ => None,
+    };
+    Config {
+        credential: arc_swap::ArcSwapOption::from(credential),
+        ..Default::default()
+    }
+}

crates/bili_sync/src/config/item.rs

@@ -0,0 +1,139 @@
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+use anyhow::Result;
+use serde::de::{Deserializer, MapAccess, Visitor};
+use serde::ser::SerializeMap;
+use serde::{Deserialize, Serialize};
+
+use crate::bilibili::{CollectionItem, CollectionType};
+use crate::utils::filenamify::filenamify;
+
+/// 稍后再看的配置
+#[derive(Serialize, Deserialize, Default)]
+pub struct WatchLaterConfig {
+    pub enabled: bool,
+    pub path: PathBuf,
+}
+
+/// NFO 文件使用的时间类型
+#[derive(Serialize, Deserialize, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum NFOTimeType {
+    #[default]
+    FavTime,
+    PubTime,
+}
+
+/// 并发下载相关的配置
+#[derive(Serialize, Deserialize)]
+pub struct ConcurrentLimit {
+    pub video: usize,
+    pub page: usize,
+    pub rate_limit: Option<RateLimit>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct RateLimit {
+    pub limit: usize,
+    pub duration: u64,
+}
+
+impl Default for ConcurrentLimit {
+    fn default() -> Self {
+        Self {
+            video: 3,
+            page: 2,
+            // 默认的限速配置，每 250ms 允许请求 4 次
+            rate_limit: Some(RateLimit {
+                limit: 4,
+                duration: 250,
+            }),
+        }
+    }
+}
+
+pub trait PathSafeTemplate {
+    fn path_safe_register(&mut self, name: &'static str, template: &'static str) -> Result<()>;
+    fn path_safe_render(&self, name: &'static str, data: &serde_json::Value) -> Result<String>;
+}
+
+/// 通过将模板字符串中的分隔符替换为自定义的字符串，使得模板字符串中的分隔符得以保留
+impl PathSafeTemplate for handlebars::Handlebars<'_> {
+    fn path_safe_register(&mut self, name: &'static str, template: &'static str) -> Result<()> {
+        Ok(self.register_template_string(name, template.replace(std::path::MAIN_SEPARATOR_STR, "__SEP__"))?)
+    }
+
+    fn path_safe_render(&self, name: &'static str, data: &serde_json::Value) -> Result<String> {
+        Ok(filenamify(&self.render(name, data)?).replace("__SEP__", std::path::MAIN_SEPARATOR_STR))
+    }
+}
+/* 后面是用于自定义 Collection 的序列化、反序列化的样板代码 */
+pub(super) fn serialize_collection_list<S>(
+    collection_list: &HashMap<CollectionItem, PathBuf>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    let mut map = serializer.serialize_map(Some(collection_list.len()))?;
+    for (k, v) in collection_list {
+        let prefix = match k.collection_type {
+            CollectionType::Series => "series",
+            CollectionType::Season => "season",
+        };
+        map.serialize_entry(&[prefix, &k.mid, &k.sid].join(":"), v)?;
+    }
+    map.end()
+}
+
+pub(super) fn deserialize_collection_list<'de, D>(deserializer: D) -> Result<HashMap<CollectionItem, PathBuf>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    struct CollectionListVisitor;
+
+    impl<'de> Visitor<'de> for CollectionListVisitor {
+        type Value = HashMap<CollectionItem, PathBuf>;
+
+        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+            formatter.write_str("a map of collection list")
+        }
+
+        fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+        where
+            A: MapAccess<'de>,
+        {
+            let mut collection_list = HashMap::new();
+            while let Some((key, value)) = map.next_entry::<String, PathBuf>()? {
+                let collection_item = match key.split(':').collect::<Vec<&str>>().as_slice() {
+                    [prefix, mid, sid] => {
+                        let collection_type = match *prefix {
+                            "series" => CollectionType::Series,
+                            "season" => CollectionType::Season,
+                            _ => {
+                                return Err(serde::de::Error::custom(
+                                    "invalid collection type, should be series or season",
+                                ))
+                            }
+                        };
+                        CollectionItem {
+                            mid: mid.to_string(),
+                            sid: sid.to_string(),
+                            collection_type,
+                        }
+                    }
+                    _ => {
+                        return Err(serde::de::Error::custom(
+                            "invalid collection key, should be series:mid:sid or season:mid:sid",
+                        ))
+                    }
+                };
+                collection_list.insert(collection_item, value);
+            }
+            Ok(collection_list)
+        }
+    }
+
+    deserializer.deserialize_map(CollectionListVisitor)
+}

crates/bili_sync/src/config/mod.rs

@@ -0,0 +1,148 @@
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use anyhow::Result;
+use arc_swap::ArcSwapOption;
+use serde::{Deserialize, Serialize};
+
+mod clap;
+mod global;
+mod item;
+
+use crate::bilibili::{CollectionItem, Credential, DanmakuOption, FilterOption};
+pub use crate::config::global::{ARGS, CONFIG, CONFIG_DIR, TEMPLATE};
+use crate::config::item::{deserialize_collection_list, serialize_collection_list, ConcurrentLimit};
+pub use crate::config::item::{NFOTimeType, PathSafeTemplate, RateLimit, WatchLaterConfig};
+
+fn default_time_format() -> String {
+    "%Y-%m-%d".to_string()
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Config {
+    pub credential: ArcSwapOption<Credential>,
+    pub filter_option: FilterOption,
+    #[serde(default)]
+    pub danmaku_option: DanmakuOption,
+    pub favorite_list: HashMap<String, PathBuf>,
+    #[serde(
+        default,
+        serialize_with = "serialize_collection_list",
+        deserialize_with = "deserialize_collection_list"
+    )]
+    pub collection_list: HashMap<CollectionItem, PathBuf>,
+    #[serde(default)]
+    pub submission_list: HashMap<String, PathBuf>,
+    #[serde(default)]
+    pub watch_later: WatchLaterConfig,
+    pub video_name: Cow<'static, str>,
+    pub page_name: Cow<'static, str>,
+    pub interval: u64,
+    pub upper_path: PathBuf,
+    #[serde(default)]
+    pub nfo_time_type: NFOTimeType,
+    #[serde(default)]
+    pub concurrent_limit: ConcurrentLimit,
+    #[serde(default = "default_time_format")]
+    pub time_format: String,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            credential: ArcSwapOption::from(Some(Arc::new(Credential::default()))),
+            filter_option: FilterOption::default(),
+            danmaku_option: DanmakuOption::default(),
+            favorite_list: HashMap::new(),
+            collection_list: HashMap::new(),
+            submission_list: HashMap::new(),
+            watch_later: Default::default(),
+            video_name: Cow::Borrowed("{{title}}"),
+            page_name: Cow::Borrowed("{{bvid}}"),
+            interval: 1200,
+            upper_path: CONFIG_DIR.join("upper_face"),
+            nfo_time_type: NFOTimeType::FavTime,
+            concurrent_limit: ConcurrentLimit::default(),
+            time_format: default_time_format(),
+        }
+    }
+}
+
+impl Config {
+    pub fn save(&self) -> Result<()> {
+        let config_path = CONFIG_DIR.join("config.toml");
+        std::fs::create_dir_all(&*CONFIG_DIR)?;
+        std::fs::write(config_path, toml::to_string_pretty(self)?)?;
+        Ok(())
+    }
+
+    #[cfg(not(test))]
+    fn load() -> Result<Self> {
+        let config_path = CONFIG_DIR.join("config.toml");
+        let config_content = std::fs::read_to_string(config_path)?;
+        Ok(toml::from_str(&config_content)?)
+    }
+
+    #[cfg(not(test))]
+    pub fn check(&self) {
+        let mut ok = true;
+        if self.favorite_list.is_empty() && self.collection_list.is_empty() && !self.watch_later.enabled {
+            ok = false;
+            error!("没有配置任何需要扫描的内容，程序空转没有意义");
+        }
+        if self.watch_later.enabled && !self.watch_later.path.is_absolute() {
+            error!(
+                "稍后再看保存的路径应为绝对路径，检测到：{}",
+                self.watch_later.path.display()
+            );
+        }
+        for path in self.favorite_list.values() {
+            if !path.is_absolute() {
+                ok = false;
+                error!("收藏夹保存的路径应为绝对路径，检测到: {}", path.display());
+            }
+        }
+        if !self.upper_path.is_absolute() {
+            ok = false;
+            error!("up 主头像保存的路径应为绝对路径");
+        }
+        if self.video_name.is_empty() {
+            ok = false;
+            error!("未设置 video_name 模板");
+        }
+        if self.page_name.is_empty() {
+            ok = false;
+            error!("未设置 page_name 模板");
+        }
+        let credential = self.credential.load();
+        match credential.as_deref() {
+            Some(credential) => {
+                if credential.sessdata.is_empty()
+                    || credential.bili_jct.is_empty()
+                    || credential.buvid3.is_empty()
+                    || credential.dedeuserid.is_empty()
+                    || credential.ac_time_value.is_empty()
+                {
+                    ok = false;
+                    error!("Credential 信息不完整，请确保填写完整");
+                }
+            }
+            None => {
+                ok = false;
+                error!("未设置 Credential 信息");
+            }
+        }
+        if !(self.concurrent_limit.video > 0 && self.concurrent_limit.page > 0) {
+            ok = false;
+            error!("允许的并发数必须大于 0");
+        }
+        if !ok {
+            panic!(
+                "位于 {} 的配置文件不合法，请参考提示信息修复后继续运行",
+                CONFIG_DIR.join("config.toml").display()
+            );
+        }
+    }
+}

crates/bili_sync/src/downloader.rs

@@ -51,8 +51,6 @@ impl Downloader {
                 _ => Err(anyhow!("ffmpeg error")),
             };
         }
-        let _ = fs::remove_file(video_path).await;
-        let _ = fs::remove_file(audio_path).await;
         Ok(())
     }
 }

crates/bili_sync/src/main.rs

@@ -9,7 +9,6 @@ mod downloader;
 mod error;
 mod utils;
 mod workflow;
-use std::time::Duration;
 
 use once_cell::sync::Lazy;
 use tokio::time;
@@ -29,35 +28,58 @@ async fn main() {
     let connection = database_connection().await.expect("获取数据库连接失败");
     let mut anchor = chrono::Local::now().date_naive();
     let bili_client = BiliClient::new();
+    let watch_later_config = &CONFIG.watch_later;
     loop {
-        if let Err(e) = bili_client.is_login().await {
-            error!("检查登录状态时遇到错误：{e}，等待下一轮执行");
-            time::sleep(Duration::from_secs(CONFIG.interval)).await;
-            continue;
-        }
-        if anchor != chrono::Local::now().date_naive() {
-            if let Err(e) = bili_client.check_refresh().await {
-                error!("检查刷新 Credential 遇到错误：{e}，等待下一轮执行");
-                time::sleep(Duration::from_secs(CONFIG.interval)).await;
-                continue;
+        'inner: {
+            match bili_client.wbi_img().await.map(|wbi_img| wbi_img.into()) {
+                Ok(Some(mixin_key)) => bilibili::set_global_mixin_key(mixin_key),
+                Ok(_) => {
+                    error!("获取 mixin key 失败，无法进行 wbi 签名，等待下一轮执行");
+                    break 'inner;
+                }
+                Err(e) => {
+                    error!("获取 mixin key 时遇到错误：{e}，等待下一轮执行");
+                    break 'inner;
+                }
+            };
+            if anchor != chrono::Local::now().date_naive() {
+                if let Err(e) = bili_client.check_refresh().await {
+                    error!("检查刷新 Credential 遇到错误：{e}，等待下一轮执行");
+                    break 'inner;
+                }
+                anchor = chrono::Local::now().date_naive();
             }
-            anchor = chrono::Local::now().date_naive();
-        }
-        for (fid, path) in &CONFIG.favorite_list {
-            if let Err(e) = process_video_list(Args::Favorite { fid }, &bili_client, path, &connection).await {
-                error!("处理收藏夹 {fid} 时遇到非预期的错误：{e}");
+            for (fid, path) in &CONFIG.favorite_list {
+                if let Err(e) = process_video_list(Args::Favorite { fid }, &bili_client, path, &connection).await {
+                    error!("处理收藏夹 {fid} 时遇到非预期的错误：{e}");
+                }
             }
-        }
-        info!("所有收藏夹处理完毕");
-        for (collection_item, path) in &CONFIG.collection_list {
-            if let Err(e) =
-                process_video_list(Args::Collection { collection_item }, &bili_client, path, &connection).await
-            {
-                error!("处理合集 {collection_item:?} 时遇到非预期的错误：{e}");
+            info!("所有收藏夹处理完毕");
+            for (collection_item, path) in &CONFIG.collection_list {
+                if let Err(e) =
+                    process_video_list(Args::Collection { collection_item }, &bili_client, path, &connection).await
+                {
+                    error!("处理合集 {collection_item:?} 时遇到非预期的错误：{e}");
+                }
             }
+            info!("所有合集处理完毕");
+            if watch_later_config.enabled {
+                if let Err(e) =
+                    process_video_list(Args::WatchLater, &bili_client, &watch_later_config.path, &connection).await
+                {
+                    error!("处理稍后再看时遇到非预期的错误：{e}");
+                }
+            }
+            info!("稍后再看处理完毕");
+            for (upper_id, path) in &CONFIG.submission_list {
+                if let Err(e) = process_video_list(Args::Submission { upper_id }, &bili_client, path, &connection).await
+                {
+                    error!("处理 UP 主 {upper_id} 投稿时遇到非预期的错误：{e}");
+                }
+            }
+            info!("所有 UP 主投稿处理完毕");
+            info!("本轮任务执行完毕，等待下一轮执行");
         }
-        info!("所有合集处理完毕");
-        info!("本轮任务执行完毕，等待下一轮执行");
-        tokio::time::sleep(std::time::Duration::from_secs(CONFIG.interval)).await;
+        time::sleep(time::Duration::from_secs(CONFIG.interval)).await;
     }
 }

crates/bili_sync/src/utils/convert.rs

@@ -1,8 +1,9 @@
-use sea_orm::ActiveValue::NotSet;
-use sea_orm::{IntoActiveModel, Set};
+use sea_orm::ActiveValue::{NotSet, Set};
+use sea_orm::IntoActiveModel;
 use serde_json::json;
 
 use crate::bilibili::VideoInfo;
+use crate::config::CONFIG;
 use crate::utils::id_time_key;
 
 impl VideoInfo {
@@ -90,32 +91,112 @@ impl VideoInfo {
                 upper_face: Set(upper.face.clone()),
                 ..base_model
             },
+            VideoInfo::WatchLater {
+                title,
+                bvid,
+                intro,
+                cover,
+                upper,
+                ctime,
+                fav_time,
+                pubtime,
+                state,
+            } => bili_sync_entity::video::ActiveModel {
+                bvid: Set(bvid.clone()),
+                name: Set(title.clone()),
+                category: Set(2), // 稍后再看里的内容类型肯定是视频
+                intro: Set(intro.clone()),
+                cover: Set(cover.clone()),
+                ctime: Set(ctime.naive_utc()),
+                pubtime: Set(pubtime.naive_utc()),
+                favtime: Set(fav_time.naive_utc()),
+                download_status: Set(0),
+                valid: Set(*state == 0),
+                tags: Set(None),
+                single_page: Set(None),
+                upper_id: Set(upper.mid),
+                upper_name: Set(upper.name.clone()),
+                upper_face: Set(upper.face.clone()),
+                ..base_model
+            },
+            VideoInfo::Submission {
+                title,
+                bvid,
+                intro,
+                cover,
+                ctime,
+            } => bili_sync_entity::video::ActiveModel {
+                bvid: Set(bvid.clone()),
+                name: Set(title.clone()),
+                intro: Set(intro.clone()),
+                cover: Set(cover.clone()),
+                ctime: Set(ctime.naive_utc()),
+                category: Set(2), // 投稿视频的内容类型肯定是视频
+                valid: Set(true),
+                ..base_model
+            },
         }
     }
 
     pub fn to_fmt_args(&self) -> Option<serde_json::Value> {
         match self {
-            VideoInfo::Simple { .. } => None, // 不能从简单的视频信息中构造格式化参数
-            VideoInfo::Detail { title, bvid, upper, .. } => Some(json!({
-                "bvid": &bvid,
-                "title": &title,
-                "upper_name": &upper.name,
-                "upper_mid": &upper.mid,
-            })),
-            VideoInfo::View { title, bvid, upper, .. } => Some(json!({
+            VideoInfo::Simple { .. } | VideoInfo::Submission { .. } => None, // 不能从简单视频信息中构造格式化参数
+            VideoInfo::Detail {
+                title,
+                bvid,
+                upper,
+                pubtime,
+                fav_time,
+                ..
+            }
+            | VideoInfo::WatchLater {
+                title,
+                bvid,
+                upper,
+                pubtime,
+                fav_time,
+                ..
+            } => Some(json!({
                 "bvid": &bvid,
                 "title": &title,
                 "upper_name": &upper.name,
                 "upper_mid": &upper.mid,
+                "pubtime": pubtime.format(&CONFIG.time_format).to_string(),
+                "fav_time": fav_time.format(&CONFIG.time_format).to_string(),
             })),
+            VideoInfo::View {
+                title,
+                bvid,
+                upper,
+                pubtime,
+                ..
+            } => {
+                let pubtime = pubtime.format(&CONFIG.time_format).to_string();
+                Some(json!({
+                    "bvid": &bvid,
+                    "title": &title,
+                    "upper_name": &upper.name,
+                    "upper_mid": &upper.mid,
+                    "pubtime": &pubtime,
+                    "fav_time": &pubtime,
+                }))
+            }
         }
     }
 
     pub fn video_key(&self) -> String {
         match self {
             // 对于合集没有 fav_time，只能用 pubtime 代替
-            VideoInfo::Simple { bvid, pubtime, .. } => id_time_key(bvid, pubtime),
-            VideoInfo::Detail { bvid, fav_time, .. } => id_time_key(bvid, fav_time),
+            VideoInfo::Simple {
+                bvid, pubtime: time, ..
+            }
+            | VideoInfo::Detail {
+                bvid, fav_time: time, ..
+            }
+            | VideoInfo::WatchLater {
+                bvid, fav_time: time, ..
+            }
+            | VideoInfo::Submission { bvid, ctime: time, .. } => id_time_key(bvid, time),
             // 详情接口返回的数据仅用于填充详情，不会被作为 video_key
             _ => unreachable!(),
         }
@@ -123,8 +204,10 @@ impl VideoInfo {
 
     pub fn bvid(&self) -> &str {
         match self {
-            VideoInfo::Simple { bvid, .. } => bvid,
-            VideoInfo::Detail { bvid, .. } => bvid,
+            VideoInfo::Simple { bvid, .. }
+            | VideoInfo::Detail { bvid, .. }
+            | VideoInfo::WatchLater { bvid, .. }
+            | VideoInfo::Submission { bvid, .. } => bvid,
             // 同上
             _ => unreachable!(),
         }

crates/bili_sync/src/utils/filenamify.rs

@@ -0,0 +1,61 @@
+macro_rules! regex {
+    ($re:literal $(,)?) => {{
+        static RE: once_cell::sync::OnceCell<regex::Regex> = once_cell::sync::OnceCell::new();
+        RE.get_or_init(|| regex::Regex::new($re).unwrap())
+    }};
+}
+
+pub fn filenamify<S: AsRef<str>>(input: S) -> String {
+    let reserved = regex!("[<>:\"/\\\\|?*\u{0000}-\u{001F}\u{007F}\u{0080}-\u{009F}]+");
+    let windows_reserved = regex!("^(con|prn|aux|nul|com\\d|lpt\\d)$");
+    let outer_periods = regex!("^\\.+|\\.+$");
+
+    let replacement = "_";
+
+    let input = reserved.replace_all(input.as_ref(), replacement);
+    let input = outer_periods.replace_all(input.as_ref(), replacement);
+
+    let mut result = input.into_owned();
+    if windows_reserved.is_match(result.as_str()) {
+        result.push_str(replacement);
+    }
+
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::filenamify;
+
+    #[test]
+    fn test_filenamify() {
+        assert_eq!(filenamify("foo/bar"), "foo_bar");
+        assert_eq!(filenamify("foo//bar"), "foo_bar");
+        assert_eq!(filenamify("//foo//bar//"), "_foo_bar_");
+        assert_eq!(filenamify("foo\\bar"), "foo_bar");
+        assert_eq!(filenamify("foo\\\\\\bar"), "foo_bar");
+        assert_eq!(filenamify(r"foo\\bar"), "foo_bar");
+        assert_eq!(filenamify(r"foo\\\\\\bar"), "foo_bar");
+        assert_eq!(filenamify("////foo////bar////"), "_foo_bar_");
+        assert_eq!(filenamify("foo\u{0000}bar"), "foo_bar");
+        assert_eq!(filenamify("\"foo<>bar*"), "_foo_bar_");
+        assert_eq!(filenamify("."), "_");
+        assert_eq!(filenamify(".."), "_");
+        assert_eq!(filenamify("./"), "__");
+        assert_eq!(filenamify("../"), "__");
+        assert_eq!(filenamify("../../foo/bar"), "__.._foo_bar");
+        assert_eq!(filenamify("foo.bar."), "foo.bar_");
+        assert_eq!(filenamify("foo.bar.."), "foo.bar_");
+        assert_eq!(filenamify("foo.bar..."), "foo.bar_");
+        assert_eq!(filenamify("con"), "con_");
+        assert_eq!(filenamify("com1"), "com1_");
+        assert_eq!(filenamify(":nul|"), "_nul_");
+        assert_eq!(filenamify("foo/bar/nul"), "foo_bar_nul");
+        assert_eq!(filenamify("file:///file.tar.gz"), "file_file.tar.gz");
+        assert_eq!(filenamify("http://www.google.com"), "http_www.google.com");
+        assert_eq!(
+            filenamify("https://www.youtube.com/watch?v=dQw4w9WgXcQ"),
+            "https_www.youtube.com_watch_v=dQw4w9WgXcQ"
+        );
+    }
+}

crates/bili_sync/src/utils/mod.rs

@@ -1,4 +1,5 @@
 pub mod convert;
+pub mod filenamify;
 pub mod model;
 pub mod nfo;
 pub mod status;

crates/bili_sync/src/utils/model.rs

@@ -1,11 +1,10 @@
 use anyhow::Result;
 use bili_sync_entity::*;
-use bili_sync_migration::OnConflict;
 use sea_orm::entity::prelude::*;
-use sea_orm::ActiveValue::Set;
+use sea_orm::sea_query::OnConflict;
 
 use crate::adapter::VideoListModel;
-use crate::bilibili::{PageInfo, VideoInfo};
+use crate::bilibili::VideoInfo;
 
 /// 尝试创建 Video Model，如果发生冲突则忽略
 pub async fn create_videos(
@@ -26,51 +25,6 @@ pub async fn create_videos(
     Ok(())
 }
 
-/// 创建视频的所有分 P
-pub async fn create_video_pages(
-    pages_info: &[PageInfo],
-    video_model: &video::Model,
-    connection: &impl ConnectionTrait,
-) -> Result<()> {
-    let page_models = pages_info
-        .iter()
-        .map(move |p| {
-            let (width, height) = match &p.dimension {
-                Some(d) => {
-                    if d.rotate == 0 {
-                        (Some(d.width), Some(d.height))
-                    } else {
-                        (Some(d.height), Some(d.width))
-                    }
-                }
-                None => (None, None),
-            };
-            page::ActiveModel {
-                video_id: Set(video_model.id),
-                cid: Set(p.cid),
-                pid: Set(p.page),
-                name: Set(p.name.clone()),
-                width: Set(width),
-                height: Set(height),
-                duration: Set(p.duration),
-                image: Set(p.first_frame.clone()),
-                download_status: Set(0),
-                ..Default::default()
-            }
-        })
-        .collect::<Vec<page::ActiveModel>>();
-    page::Entity::insert_many(page_models)
-        .on_conflict(
-            OnConflict::columns([page::Column::VideoId, page::Column::Pid])
-                .do_nothing()
-                .to_owned(),
-        )
-        .do_nothing()
-        .exec(connection)
-        .await?;
-    Ok(())
-}
-
 /// 更新视频 model 的下载状态
 pub async fn update_videos_model(videos: Vec<video::ActiveModel>, connection: &DatabaseConnection) -> Result<()> {
     video::Entity::insert_many(videos)

crates/bili_sync/src/utils/nfo.rs

@@ -24,7 +24,7 @@ pub struct NFOSerializer<'a>(pub ModelWrapper<'a>, pub NFOMode);
 
 /// serde xml 似乎不太好用，先这么裸着写
 /// （真是又臭又长啊
-impl<'a> NFOSerializer<'a> {
+impl NFOSerializer<'_> {
     pub async fn generate_nfo(self, nfo_time_type: &NFOTimeType) -> Result<String> {
         let mut buffer = r#"<?xml version="1.0" encoding="utf-8" standalone="yes"?>
 "#

crates/bili_sync/src/utils/status.rs

@@ -13,7 +13,7 @@ pub struct Status(u32);
 impl Status {
     /// 如果 status 整体大于等于 1 << 31，则表示任务已经被处理过，不再需要重试。
     /// 数据库可以使用 status < Status::handled() 来筛选需要处理的内容。
-    pub fn handled() -> u32 {
+    pub const fn handled() -> u32 {
         1 << 31
     }
 
@@ -32,19 +32,16 @@ impl Status {
 
     /// 从低到高检查状态，如果该位置的任务应该继续尝试执行，则返回 true，否则返回 false
     fn should_run(&self, size: usize) -> Vec<bool> {
-        assert!(size < 10, "u32 can only store 10 status");
         (0..size).map(|x| self.check_continue(x)).collect()
     }
 
     /// 如果任务的执行次数小于 STATUS_MAX_RETRY，说明可以继续运行
     fn check_continue(&self, offset: usize) -> bool {
-        assert!(offset < 10, "u32 can only store 10 status");
         self.get_status(offset) < STATUS_MAX_RETRY
     }
 
     /// 根据任务结果更新状态，如果任务成功，设置为 STATUS_OK，否则加一
     fn update_status(&mut self, result: &[Result<()>]) {
-        assert!(result.len() < 10, "u32 can only store 10 status");
         for (i, res) in result.iter().enumerate() {
             self.set_result(res, i);
         }
@@ -65,17 +62,6 @@ impl Status {
         }
     }
 
-    /// 根据 mask 设置状态，如果 mask 为 false，则清除对应的状态
-    fn set_mask(&mut self, mask: &[bool]) {
-        assert!(mask.len() < 10, "u32 can only store 10 status");
-        for (i, &m) in mask.iter().enumerate() {
-            if !m {
-                self.clear(i);
-                self.set_flag(false);
-            }
-        }
-    }
-
     fn plus_one(&mut self, offset: usize) {
         self.0 += 1 << (3 * offset);
     }
@@ -84,10 +70,6 @@ impl Status {
         self.0 |= STATUS_OK << (3 * offset);
     }
 
-    fn clear(&mut self, offset: usize) {
-        self.0 &= !(STATUS_OK << (3 * offset));
-    }
-
     fn get_status(&self, offset: usize) -> u32 {
         let helper = !0u32;
         (self.0 & (helper << (offset * 3)) & (helper >> (32 - 3 * offset - 3))) >> (offset * 3)
@@ -109,11 +91,6 @@ impl VideoStatus {
         Self(Status::new(status))
     }
 
-    pub fn set_mask(&mut self, clear: &[bool]) {
-        assert!(clear.len() == 5, "VideoStatus should have 5 status");
-        self.0.set_mask(clear)
-    }
-
     pub fn should_run(&self) -> Vec<bool> {
         self.0.should_run(5)
     }
@@ -139,11 +116,6 @@ impl PageStatus {
         Self(Status::new(status))
     }
 
-    pub fn set_mask(&mut self, clear: &[bool]) {
-        assert!(clear.len() == 4, "PageStatus should have 4 status");
-        self.0.set_mask(clear)
-    }
-
     pub fn should_run(&self) -> Vec<bool> {
         self.0.should_run(4)
     }

crates/bili_sync/src/workflow.rs

@@ -1,12 +1,9 @@
-#![allow(dead_code, unused_variables)]
-
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::pin::Pin;
 
 use anyhow::{bail, Result};
-use bili_sync_entity::{page, video};
-use filenamify::filenamify;
+use bili_sync_entity::*;
 use futures::stream::{FuturesOrdered, FuturesUnordered};
 use futures::{Future, Stream, StreamExt};
 use sea_orm::entity::prelude::*;
@@ -17,7 +14,7 @@ use tokio::sync::{Mutex, Semaphore};
 
 use crate::adapter::{video_list_from, Args, VideoListModel};
 use crate::bilibili::{BestStream, BiliClient, BiliError, Dimension, PageInfo, Video, VideoInfo};
-use crate::config::{ARGS, CONFIG, TEMPLATE};
+use crate::config::{PathSafeTemplate, ARGS, CONFIG, TEMPLATE};
 use crate::downloader::Downloader;
 use crate::error::{DownloadAbortError, ProcessPageError};
 use crate::utils::model::{create_videos, update_pages_model, update_videos_model};
@@ -31,7 +28,7 @@ pub async fn process_video_list(
     connection: &DatabaseConnection,
 ) -> Result<()> {
     let (video_list_model, video_streams) = video_list_from(args, path, bili_client, connection).await?;
-    let video_list_model = refresh_video_list(bili_client, video_list_model, video_streams, connection).await?;
+    let video_list_model = refresh_video_list(video_list_model, video_streams, connection).await?;
     let video_list_model = fetch_video_details(bili_client, video_list_model, connection).await?;
     if ARGS.scan_only {
         warn!("已开启仅扫描模式，跳过视频下载...");
@@ -42,7 +39,6 @@ pub async fn process_video_list(
 
 /// 请求接口，获取视频列表中所有新添加的视频信息，将其写入数据库
 pub async fn refresh_video_list<'a>(
-    bili_client: &'a BiliClient,
     video_list_model: Box<dyn VideoListModel>,
     video_streams: Pin<Box<dyn Stream<Item = VideoInfo> + 'a>>,
     connection: &DatabaseConnection,
@@ -76,9 +72,12 @@ pub async fn fetch_video_details(
 ) -> Result<Box<dyn VideoListModel>> {
     video_list_model.log_fetch_video_start();
     let videos_model = video_list_model.unfilled_videos(connection).await?;
-    video_list_model
-        .fetch_videos_detail(bili_client, videos_model, connection)
-        .await?;
+    for video_model in videos_model {
+        let video = Video::new(bili_client, video_model.bvid.clone());
+        video_list_model
+            .fetch_videos_detail(video, video_model, connection)
+            .await?;
+    }
     video_list_model.log_fetch_video_end();
     Ok(video_list_model)
 }
@@ -91,8 +90,7 @@ pub async fn download_unprocessed_videos(
 ) -> Result<()> {
     video_list_model.log_download_video_start();
     let unhandled_videos_pages = video_list_model.unhandled_video_pages(connection).await?;
-    // 对于视频，允许三个同时下载（视频内还有分页、不同分页还有多种下载任务）
-    let semaphore = Semaphore::new(3);
+    let semaphore = Semaphore::new(CONFIG.concurrent_limit.video);
     let downloader = Downloader::new(bili_client.client.clone());
     let mut uppers_mutex: HashMap<i64, (Mutex<()>, Mutex<()>)> = HashMap::new();
     for (video_model, _) in &unhandled_videos_pages {
@@ -243,8 +241,7 @@ pub async fn dispatch_download_page(
     if !should_run {
         return Ok(());
     }
-    // 对于视频的分页，允许两个同时下载（绝大部分是单页视频）
-    let child_semaphore = Semaphore::new(2);
+    let child_semaphore = Semaphore::new(CONFIG.concurrent_limit.page);
     let mut tasks = pages
         .into_iter()
         .map(|page_model| download_page(bili_client, video_model, page_model, &child_semaphore, downloader))
@@ -311,7 +308,7 @@ pub async fn download_page(
     let seprate_status = status.should_run();
     let is_single_page = video_model.single_page.unwrap();
     let base_path = Path::new(&video_model.path);
-    let base_name = filenamify(TEMPLATE.render(
+    let base_name = TEMPLATE.path_safe_render(
         "page",
         &json!({
             "bvid": &video_model.bvid,
@@ -320,8 +317,10 @@ pub async fn download_page(
             "upper_mid": &video_model.upper_id,
             "ptitle": &page_model.name,
             "pid": page_model.pid,
+            "pubtime": video_model.pubtime.format(&CONFIG.time_format).to_string(),
+            "fav_time": video_model.favtime.format(&CONFIG.time_format).to_string(),
         }),
-    )?);
+    )?;
     let (poster_path, video_path, nfo_path, danmaku_path, fanart_path) = if is_single_page {
         (
             base_path.join(format!("{}-poster.jpg", &base_name)),
@@ -463,15 +462,11 @@ pub async fn fetch_page_video(
         .await?
         .best_stream(&CONFIG.filter_option)?;
     match streams {
-        BestStream::Mixed(mix_stream) => {
-            downloader.fetch(mix_stream.url(), &page_path).await?;
-        }
+        BestStream::Mixed(mix_stream) => downloader.fetch(mix_stream.url(), &page_path).await,
         BestStream::VideoAudio {
             video: video_stream,
             audio: None,
-        } => {
-            downloader.fetch(video_stream.url(), &page_path).await?;
-        }
+        } => downloader.fetch(video_stream.url(), &page_path).await,
         BestStream::VideoAudio {
             video: video_stream,
             audio: Some(audio_stream),
@@ -480,12 +475,17 @@ pub async fn fetch_page_video(
                 page_path.with_extension("tmp_video"),
                 page_path.with_extension("tmp_audio"),
             );
-            downloader.fetch(video_stream.url(), &tmp_video_path).await?;
-            downloader.fetch(audio_stream.url(), &tmp_audio_path).await?;
-            downloader.merge(&tmp_video_path, &tmp_audio_path, &page_path).await?;
+            let res = async {
+                downloader.fetch(video_stream.url(), &tmp_video_path).await?;
+                downloader.fetch(audio_stream.url(), &tmp_audio_path).await?;
+                downloader.merge(&tmp_video_path, &tmp_audio_path, &page_path).await
+            }
+            .await;
+            let _ = fs::remove_file(tmp_video_path).await;
+            let _ = fs::remove_file(tmp_audio_path).await;
+            res
         }
     }
-    Ok(())
 }
 
 pub async fn fetch_page_danmaku(
@@ -503,8 +503,7 @@ pub async fn fetch_page_danmaku(
         .get_danmaku_writer(page_info)
         .await?
         .write(danmaku_path)
-        .await?;
-    Ok(())
+        .await
 }
 
 pub async fn generate_page_nfo(
@@ -613,15 +612,49 @@ mod tests {
             }
         });
         template.register_helper("truncate", Box::new(truncate));
-        let _ = template.register_template_string("video", "test{{bvid}}test");
-        let _ = template.register_template_string("test_truncate", "哈哈，{{ truncate title 30 }}");
+        let _ = template.path_safe_register("video", "test{{bvid}}test");
+        let _ = template.path_safe_register("test_truncate", "哈哈，{{ truncate title 30 }}");
+        let _ = template.path_safe_register("test_path_unix", "{{ truncate title 7 }}/test/a");
+        let _ = template.path_safe_register("test_path_windows", r"{{ truncate title 7 }}\\test\\a");
+        #[cfg(not(windows))]
+        {
+            assert_eq!(
+                template
+                    .path_safe_render("test_path_unix", &json!({"title": "关注/永雏塔菲喵"}))
+                    .unwrap(),
+                "关注_永雏塔菲/test/a"
+            );
+            assert_eq!(
+                template
+                    .path_safe_render("test_path_windows", &json!({"title": "关注/永雏塔菲喵"}))
+                    .unwrap(),
+                "关注_永雏塔菲_test_a"
+            );
+        }
+        #[cfg(windows)]
+        {
+            assert_eq!(
+                template
+                    .path_safe_render("test_path_unix", &json!({"title": "关注/永雏塔菲喵"}))
+                    .unwrap(),
+                "关注_永雏塔菲_test_a"
+            );
+            assert_eq!(
+                template
+                    .path_safe_render("test_path_windows", &json!({"title": "关注/永雏塔菲喵"}))
+                    .unwrap(),
+                r"关注_永雏塔菲\\test\\a"
+            );
+        }
         assert_eq!(
-            template.render("video", &json!({"bvid": "BV1b5411h7g7"})).unwrap(),
+            template
+                .path_safe_render("video", &json!({"bvid": "BV1b5411h7g7"}))
+                .unwrap(),
             "testBV1b5411h7g7test"
         );
         assert_eq!(
             template
-                .render(
+                .path_safe_render(
                     "test_truncate",
                     &json!({"title": "你说得对，但是 Rust 是由 Mozilla 自主研发的一款全新的编译期格斗游戏。\
                     编译将发生在一个被称作「Cargo」的构建系统中。在这里，被引用的指针将被授予「生命周期」之力，导引对象安全。\

crates/bili_sync_entity/src/entities/mod.rs

@@ -5,4 +5,6 @@ pub mod prelude;
 pub mod collection;
 pub mod favorite;
 pub mod page;
+pub mod submission;
 pub mod video;
+pub mod watch_later;

crates/bili_sync_entity/src/entities/submission.rs

@@ -0,0 +1,19 @@
+//! `SeaORM` Entity. Generated by sea-orm-codegen 0.12.15
+
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq)]
+#[sea_orm(table_name = "submission")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub upper_id: i64,
+    pub upper_name: String,
+    pub path: String,
+    pub created_at: String,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}
+
+impl ActiveModelBehavior for ActiveModel {}

crates/bili_sync_entity/src/entities/video.rs

@@ -9,6 +9,8 @@ pub struct Model {
     pub id: i32,
     pub collection_id: Option<i32>,
     pub favorite_id: Option<i32>,
+    pub watch_later_id: Option<i32>,
+    pub submission_id: Option<i32>,
     pub upper_id: i64,
     pub upper_name: String,
     pub upper_face: String,

crates/bili_sync_entity/src/entities/watch_later.rs

@@ -0,0 +1,17 @@
+//! `SeaORM` Entity. Generated by sea-orm-codegen 0.12.15
+
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq)]
+#[sea_orm(table_name = "watch_later")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub path: String,
+    pub created_at: String,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}
+
+impl ActiveModelBehavior for ActiveModel {}

crates/bili_sync_migration/src/lib.rs

@@ -2,6 +2,8 @@ pub use sea_orm_migration::prelude::*;
 
 mod m20240322_000001_create_table;
 mod m20240505_130850_add_collection;
+mod m20240709_130914_watch_later;
+mod m20240724_161008_submission;
 
 pub struct Migrator;
 
@@ -11,6 +13,8 @@ impl MigratorTrait for Migrator {
         vec![
             Box::new(m20240322_000001_create_table::Migration),
             Box::new(m20240505_130850_add_collection::Migration),
+            Box::new(m20240709_130914_watch_later::Migration),
+            Box::new(m20240724_161008_submission::Migration),
         ]
     }
 }

crates/bili_sync_migration/src/m20240709_130914_watch_later.rs

@@ -0,0 +1,88 @@
+use sea_orm_migration::prelude::*;
+
+#[derive(DeriveMigrationName)]
+pub struct Migration;
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        let db = manager.get_connection();
+        manager
+            .create_table(
+                Table::create()
+                    .table(WatchLater::Table)
+                    .if_not_exists()
+                    .col(
+                        ColumnDef::new(WatchLater::Id)
+                            .unsigned()
+                            .not_null()
+                            .auto_increment()
+                            .primary_key(),
+                    )
+                    .col(ColumnDef::new(WatchLater::Path).string().not_null())
+                    .col(
+                        ColumnDef::new(WatchLater::CreatedAt)
+                            .timestamp()
+                            .default(Expr::current_timestamp())
+                            .not_null(),
+                    )
+                    .to_owned(),
+            )
+            .await?;
+        manager
+            .drop_index(
+                Index::drop()
+                    .table(Video::Table)
+                    .name("idx_video_cid_fid_bvid")
+                    .to_owned(),
+            )
+            .await?;
+        manager
+            .alter_table(
+                Table::alter()
+                    .table(Video::Table)
+                    .add_column(ColumnDef::new(Video::WatchLaterId).unsigned().null())
+                    .to_owned(),
+            )
+            .await?;
+        db.execute_unprepared("CREATE UNIQUE INDEX `idx_video_unique` ON `video` (ifnull(`collection_id`, -1), ifnull(`favorite_id`, -1), ifnull(`watch_later_id`, -1), `bvid`)")
+            .await?;
+        Ok(())
+    }
+
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        let db = manager.get_connection();
+        manager
+            .drop_index(Index::drop().table(Video::Table).name("idx_video_unique").to_owned())
+            .await?;
+        db.execute_unprepared("DELETE FROM video WHERE watch_later_id IS NOT NULL")
+            .await?;
+        manager
+            .alter_table(
+                Table::alter()
+                    .table(Video::Table)
+                    .drop_column(Video::WatchLaterId)
+                    .to_owned(),
+            )
+            .await?;
+        db.execute_unprepared("CREATE UNIQUE INDEX `idx_video_cid_fid_bvid` ON `video` (ifnull(`collection_id`, -1), ifnull(`favorite_id`, -1), `bvid`)")
+            .await?;
+        manager
+            .drop_table(Table::drop().table(WatchLater::Table).to_owned())
+            .await
+    }
+}
+
+#[derive(DeriveIden)]
+enum WatchLater {
+    Table,
+    Id,
+    Path,
+    CreatedAt,
+}
+
+#[derive(DeriveIden)]
+enum Video {
+    Table,
+    WatchLaterId,
+}

crates/bili_sync_migration/src/m20240724_161008_submission.rs

@@ -0,0 +1,87 @@
+use sea_orm_migration::prelude::*;
+
+#[derive(DeriveMigrationName)]
+pub struct Migration;
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        let db = manager.get_connection();
+        manager
+            .create_table(
+                Table::create()
+                    .table(Submission::Table)
+                    .if_not_exists()
+                    .col(
+                        ColumnDef::new(Submission::Id)
+                            .unsigned()
+                            .not_null()
+                            .auto_increment()
+                            .primary_key(),
+                    )
+                    .col(ColumnDef::new(Submission::UpperId).unique_key().unsigned().not_null())
+                    .col(ColumnDef::new(Submission::UpperName).string().not_null())
+                    .col(ColumnDef::new(Submission::Path).string().not_null())
+                    .col(
+                        ColumnDef::new(Submission::CreatedAt)
+                            .timestamp()
+                            .default(Expr::current_timestamp())
+                            .not_null(),
+                    )
+                    .to_owned(),
+            )
+            .await?;
+        manager
+            .drop_index(Index::drop().table(Video::Table).name("idx_video_unique").to_owned())
+            .await?;
+        manager
+            .alter_table(
+                Table::alter()
+                    .table(Video::Table)
+                    .add_column(ColumnDef::new(Video::SubmissionId).unsigned().null())
+                    .to_owned(),
+            )
+            .await?;
+        db.execute_unprepared("CREATE UNIQUE INDEX `idx_video_unique` ON `video` (ifnull(`collection_id`, -1), ifnull(`favorite_id`, -1), ifnull(`watch_later_id`, -1), ifnull(`submission_id`, -1), `bvid`)")
+            .await?;
+        Ok(())
+    }
+
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        let db = manager.get_connection();
+        manager
+            .drop_index(Index::drop().table(Video::Table).name("idx_video_unique").to_owned())
+            .await?;
+        db.execute_unprepared("DELETE FROM video WHERE submission_id IS NOT NULL")
+            .await?;
+        manager
+            .alter_table(
+                Table::alter()
+                    .table(Video::Table)
+                    .drop_column(Video::SubmissionId)
+                    .to_owned(),
+            )
+            .await?;
+        db.execute_unprepared("CREATE UNIQUE INDEX `idx_video_unique` ON `video` (ifnull(`collection_id`, -1), ifnull(`favorite_id`, -1), ifnull(`watch_later_id`, -1), `bvid`)")
+            .await?;
+        manager
+            .drop_table(Table::drop().table(Submission::Table).to_owned())
+            .await
+    }
+}
+
+#[derive(DeriveIden)]
+enum Submission {
+    Table,
+    Id,
+    UpperId,
+    UpperName,
+    Path,
+    CreatedAt,
+}
+
+#[derive(DeriveIden)]
+enum Video {
+    Table,
+    SubmissionId,
+}

docs/.vitepress/config.mts

@@ -21,7 +21,7 @@ export default defineConfig({
 		nav: [
 			{ text: "主页", link: "/" },
 			{
-				text: "v2.1.0",
+				text: "v2.2.0",
 				items: [
 					{
 						text: "程序更新",
@@ -47,6 +47,7 @@ export default defineConfig({
 				items: [
 					{ text: "配置文件", link: "/configuration" },
 					{ text: "命令行参数", link: "/args" },
+					{ text: "工作原理", link: "/design" },
 				],
 			},
 			{
@@ -57,6 +58,7 @@ export default defineConfig({
 						text: "获取视频合集/视频列表信息",
 						link: "/collection",
 					},
+					{ text: "获取投稿信息", link: "/submission" },
 				],
 			},
 		],

docs/.vitepress/theme/index.css

@@ -0,0 +1,7 @@
+.medium-zoom-overlay {
+    z-index: 30;
+}
+
+.medium-zoom-image--opened {
+    z-index: 31;
+}

docs/.vitepress/theme/index.ts

@@ -0,0 +1,22 @@
+import DefaultTheme from "vitepress/theme";
+import { onMounted, watch, nextTick } from "vue";
+import { useRoute } from "vitepress";
+import mediumZoom from "medium-zoom";
+import "./index.css";
+
+export default {
+	...DefaultTheme,
+	setup() {
+		const route = useRoute();
+		const initZoom = () => {
+			mediumZoom(".main img", { background: "var(--vp-c-bg)" });
+		};
+		onMounted(() => {
+			initZoom();
+		});
+		watch(
+			() => route.path,
+			() => nextTick(() => initZoom()),
+		);
+	},
+};

docs/collection.md

@@ -11,7 +11,7 @@
 2. 两者的图标不同
 
 如下图所示，“合集【命运方舟全剧情解说】”是视频合集，而“阿拉德冒险记”是视频列表。
-![image](./assets/collection.png)
+![image](./assets/collection.webp)
 
 在 bili-sync 的设计中，视频合集的 key 为 `season:{mid}:{season_id}`，而视频列表的 key 为 `series:{mid}:{series_id}`。
 
@@ -21,12 +21,12 @@
 
 ### 视频合集
 
-![image](./assets/season.png)
+![image](./assets/season.webp)
 
 该视频合集的 key 为 `season:521722088:1987140`。
 
 ### 视频列表
 
-![image](./assets/series.png)
+![image](./assets/series.webp)
 
 该视频列表的 key 为 `series:521722088:387214`。

docs/configuration.md

@@ -32,12 +32,23 @@
 
 这两个参数支持使用模板，其中用 <code v-pre>{{  }}</code> 包裹的模板变量在执行时会被动态替换为对应的内容。
 
-对于 `video_name`，支持设置 bvid（视频编号）、title（视频标题）、upper_name（up 主名称）、upper_mid（up 主 id）。
+对于 `video_name`，支持设置 bvid（视频编号）、title（视频标题）、upper_name（up 主名称）、upper_mid（up 主 id）、pubtime（视频发布时间）、fav_time（视频收藏时间）。
 
 对于 `page_name`，除支持 video 的全部参数外，还支持 ptitle（分 P 标题）、pid（分 P 页号）。
 
 为了解决文件名可能过长的问题，程序为模板引入了 `truncate` 函数。如 <code v-pre>{{ truncate title 10 }}</code> 表示截取 `title` 的前 10 个字符。
 
+> [!TIP]
+> 1. 仅收藏夹视频会区分 `fav_time` 和 `pubtime`，其它类型下载两者的取值是完全相同的；
+> 2. `fav_time` 和 `pubtime` 的格式受 `time_format` 参数控制，详情可参考 [time_format 小节](#time-format)。
+
+此外，`video_name` 和 `page_name` 还支持使用路径分割符，如 <code v-pre>{{ upper_mid }}/{{ title }}_{{ pubtime }}</code> 表示视频会根据 UP 主 id 将视频分到不同的文件夹中。
+
+推荐仅在 `video_name` 中使用路径分割符，暂不清楚在 `page_name` 中使用路径分割符导致分页存储到子文件夹后是否还能被媒体服务器正确识别。
+
+> [!CAUTION]
+> **路径分隔符**在不同平台定义不同，Windows 下为 `\`，MacOS 和 Linux 下为 `/`。
+
 ## `interval`
 
 表示程序每次执行扫描下载的间隔时间，单位为秒。
@@ -50,7 +61,11 @@ UP 主头像和信息的保存位置。对于使用 Emby、Jellyfin 媒体服务
 
 表示在视频信息中使用的时间类型，可选值为 `favtime`（收藏时间）和 `pubtime`（发布时间）。
 
-视频合集/视频列表不存在 `favtime`，程序实现中将 `favtime` 设置为与 `pubtime` 相同，因此该设置对视频合集/视频列表没有影响。
+仅收藏夹视频会区分 `fav_time` 和 `pubtime`，其它类型下载两者取值相同。
+
+## `time_format`
+
+时间格式，用于设置 `fav_time` 和 `pubtime` 在 `video_name`、 `page_name` 中使用时的显示格式，支持的格式符号可以参考 [chrono strftime 文档](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)。
 
 ## `credential`
 
@@ -179,3 +194,45 @@ UP 主头像和信息的保存位置。对于使用 Emby、Jellyfin 媒体服务
 ```
 
 具体说明可以参考[这里](/collection)。
+
+## `submission_list`
+
+你想要下载的 UP 主投稿与想要保存的位置。简单示例：
+```toml
+9183758 = "/home/amtoaer/Downloads/bili-sync/测试投稿"
+```
+UP 主 ID 的获取方式可以参考[这里](/submission)。
+
+## `watch_later`
+
+设置稍后再看的扫描开关与保存位置。
+
+如果你希望下载稍后再看列表中的视频，可以将 `enabled` 设置为 `true`，并填写 `path`。
+
+```toml
+enabled = true
+path = "/home/amtoaer/Downloads/bili-sync/稍后再看"
+```
+
+## `concurrent_limit`
+
+对 bili-sync 的并发下载进行多方面的限制，避免 api 请求过于频繁导致的风控。其中 video 和 page 表示下载任务的并发数，rate_limit 表示 api 请求的流量限制。默认取值为：
+```toml
+[concurrent_limit]
+video = 3
+page = 2
+
+[concurrent_limit.rate_limit]
+limit = 4
+duration = 250
+```
+
+具体来说，程序的处理逻辑是严格从上到下的，即程序会首先并发处理多个 video，每个 video 内再并发处理多个 page，程序的并行度可以简单衡量为 `video * page`（很多 video 都只有单个 page，实际会更接近 `video * 1`），配置项中的 `video` 和 `page` 两个参数就是控制此处的，调节这两个参数可以宏观上控制程序的并行度。
+
+另一方面，每个执行的任务内部都会发起若干 api 请求以获取信息，这些请求的整体频率受到 `rate_limit` 的限制，使用漏桶算法实现。如默认配置表示的是每 250ms 允许 4 个 api 请求，超过这个频率的请求会被暂时阻塞，直到漏桶中有空间为止。调节 `rate_limit` 可以从微观上控制程序的并行度，同时也是最直接、最显著的控制 api 请求频率的方法。
+
+据观察 b 站风控限制大多集中在主站，因此目前 `rate_limit` 仅作用于主站的各类请求，如请求各类视频列表、视频信息、获取流下载地址等，对实际的视频、图片下载过程不做限制。
+
+> [!TIP]
+> 1. 一般来说，`video` 和 `page` 的值不需要过大；
+> 2. `rate_limit` 的值可以根据网络环境和 api 请求频率进行调整，如果经常遇到风控可以优先调小 limit。

docs/design.md

@@ -0,0 +1,110 @@
+# 工作原理
+
+本节会尽可能简单明了地介绍 `bili-sync` 的工作原理，让用户了解程序的整体执行过程。
+
+## b 站的视频结构
+
+在了解程序工作原理之前，我们需要先对 b 站视频的组织结构有一个大概的了解。简单来说：
+
+- 收藏夹、稍后再看、视频合集、视频列表等结构都是由一系列视频构成的列表；
+- 每个视频都有唯一的 bvid，包含了封面、描述和标签信息，并包含了一个或多个分页；
+- 每个分页都有一个唯一的 cid，包含了封面、视频、音频、弹幕。
+
+为了描述方便，在后文会将收藏夹、稍后再看这类结构统称为 video list，将视频称为 video，将分页称为 page。不难看出这三者有着很明显的层级关系：**video list 包含若干 video，video 包含若干 page**。
+
+一个非常容易混淆的点是视频合集/视频列表与多页视频的区别：
+
+> [!NOTE]
+> ![bili_collection](./assets/bili_collection.webp)
+>
+>![bili_video](./assets/bili_video.webp)
+
+这两张图中，上图是视频合集，下图是多页视频。这两者在展示上区别较小，但在结构上有相当大的不同。结合上面对 b 站视频结构的介绍，这个区别可以简单总结为：
+
++ **视频合集是由多个仅包含单个 page 的 video 组成的 video list**；
+
++ **多页视频是由多个 page 组成的 video**。
+
+这说明它们是处于两个不同层级的结构，因此程序对其的处理方式也有着相当大的不同。
+
+## 与 EMBY 媒体库的对应关系
+
+EMBY 的一般结构是： `媒体库 - 文件夹 - 电影/电视剧 - 分季/分集`，方便起见，我采用了如下的对应关系：
+
+1. **文件夹**：对应 b 站的 video list；
+2. **电视剧**： 对应 b 站的 video；
+3. **第一季的所有分集**：对应 b 站的 page。
+
+特别的，当 video 仅有一个 page 时，为了避免过多的层级，bili-sync 会将 page 展开到第二层级，变成与电视剧同级的电影。
+
+因此，**需要将媒体库类型设置为“混合内容”以支持在同个媒体库中同时显示电视剧与电影**。
+
+### 单 page 的 video
+
+![single_page](./assets/single_page.webp)
+
+### 多 page 的 video
+
+![multi_page](./assets/multi_page.webp)
+
+![multi_page_detail](./assets/multi_page_detail.webp)
+
+## 数据库设计
+
+> [!NOTE]
+> 可以[前往此处](https://github.com/amtoaer/bili-sync/tree/main/crates/bili_sync_entity/src/entities)实时查看当前版本的数据库表结构。
+
+既然拥有着明显的层级关系，那数据库表就很容易设计了。为了简化实现，程序没有额外考虑单个 video 被多个 video list 引用的情况（如一个视频同时在收藏夹和稍后再看中）。而是简单的将其设计为了不交叉的层级结构。
+
+### video list 表
+
+从上面的介绍可以看出，video list 并不是一个具体的结构，而是拥有多种实现的抽象概念。我选择将其特化实现为多张表：
+
+1. favorite：收藏夹；
+2. watch_later：稍后再看；
+3. collection: 视频合集/视频列表；
+4. ....
+
+### video 表
+
+video 表包含了 video 的基本信息，如 bvid、标题、封面、描述、标签等。此外，video 表还包含了与 video list 的关联。
+
+具体来说，每一种 video list 都在 video 表中有一个对应的列，指向 video list 表中的 id，如 favorite_id、collection_id 等。接下来将这些键与 video 的 bvid 绑在一起建立唯一索引，就可以保证在同一个 video list 中不会有重复的 video。
+
+### page 表
+
+page 表包含了 page 的基本信息，如 cid、标题、封面等。与 video 类似但更简单，page 表仅包含了与 video 的关联。
+
+## 执行过程
+
+### 初始化
+
+程序启动时会读取配置文件、迁移数据库、初始化日志等操作。如果发现需要的文件不存在，程序会自动创建。
+
+### 扫描 video list
+
+> [!WARNING]
+> b 站实现接口时为了节省资源，通过 video list 获取到的 video 列表通常是分页且不包含详细信息的。
+
+程序会扫描所有配置文件中包含的 video list，获取其中包含的 video 的简单信息并填充到数据库。在实现时需要避免频繁的全量扫描。
+
+具体到 bili-sync 的实现中，程序在请求接口时会设置按时间顺序排序的参数，确保新发布的视频位于前面。拉取过程会逐页请求，使用视频的 bvid 与 time 字段来检验视频是否已经存在于数据库中。一旦发现 bvid 与 time 均相同的记录则认为已经到达扫描过的位置，停止拉取。
+
+### 填充 video 详情
+
+将新增视频的简单信息写入数据库后，下一步会填充 video 详情。正如上文所述：**通过 video list 获取到的 video 列表通常是不包含详细信息的**，因此需要额外的请求来填充这些信息。
+
+这一步会筛选出所有未完全填充信息的 video，逐个获取 video 的详细信息（如标签、视频分页等）并填充到数据库中。
+
+在这个过程中，如果遇到 -404 错误码则说明视频无法被正常访问，程序会将该视频标记为无效并跳过。
+
+
+### 下载未处理的视频
+
+经过上面处理后，数据库中已经包含了所有需要的 video 信息，接下来只需要筛选其中“未完全下载”、“成功填充详细信息”的所有视频，并发下载即可。程序在 video 层级最多允许 3 个任务同时下载，page 层级最多允许 2 个任务同时下载。
+
+数据库中的 status 字段用于标记 video 和 page 的下载状态，视频的各个部分（封面、视频、nfo 等）包含在 status 的不同位中。程序会根据 status 的不同位来判断视频的下载状态，以此来决定是否需要下载。
+
+如果某些部分下载失败，status 字段会记录这些部分的失败次数，程序会在下次下载时重试。如果重试次数超过了设定的阈值，那么视频会被标记为下载失败，后续直接忽略。
+
+此处程序对风控做了额外的处理，一般风控发生时接下来的所有请求都会失败，因此程序检测到风控时不会认为是某个视频下载失败，而是直接终止 video list 的全部下载任务，等待下次扫描时重试。

docs/favorite.md

@@ -2,4 +2,4 @@
 
 收藏夹的 ID 获取非常简单，在网页端打开自己的收藏夹列表，切换到你想要获取的收藏夹，然后查看 URL 地址栏中的 `fid` 参数内容即可。
 
-![image](./assets/favorite.png)
+![image](./assets/favorite.webp)

docs/index.md

@@ -20,7 +20,7 @@ hero:
       text: GitHub
       link: https://github.com/amtoaer/bili-sync
   image:
-    src: /logo.png
+    src: /logo.webp
     alt: bili-sync
 
 features:

docs/introduction.md

@@ -1,7 +1,7 @@
 # bili-sync 是什么？
 
 > [!TIP]
-> 当前最新程序版本为 v2.1.0，文档将始终与最新程序版本保持一致。
+> 当前最新程序版本为 v2.2.0，文档将始终与最新程序版本保持一致。
 
 bili-sync 是一款专为 NAS 用户编写的哔哩哔哩同步工具。
 
@@ -17,13 +17,13 @@ bili-sync 是一款专为 NAS 用户编写的哔哩哔哩同步工具。
 
 
 ### 概览
-![概览](/assets/overview.png)
+![概览](/assets/overview.webp)
 ### 详情
-![详情](/assets/detail.png)
+![详情](/assets/detail.webp)
 ### 播放（使用 infuse）
-![播放](/assets/play.png)
+![播放](/assets/play.webp)
 ### 文件排布
-![文件](/assets/dir.png)
+![文件](/assets/dir.webp)
 
 ## 功能与路线图
 
@@ -36,5 +36,7 @@ bili-sync 是一款专为 NAS 用户编写的哔哩哔哩同步工具。
 - [x] 使用数据库保存媒体信息，避免对同个视频的多次请求
 - [x] 打印日志，并在请求出现风控时自动终止，等待下一轮执行
 - [x] 提供多平台的二进制可执行文件，为 Linux 平台提供了立即可用的 Docker 镜像
-- [ ] 支持对“稍后再看”内视频的自动扫描与下载
+- [x] 支持对“稍后再看”内视频的自动扫描与下载
+- [x] 支持对 UP 主投稿视频的自动扫描与下载
+- [x] 支持限制任务的并行度和接口请求频率
 - [ ] 下载单个文件时支持断点续传与并发下载

docs/package.json

@@ -2,6 +2,7 @@
 	"dependencies": {},
 	"devDependencies": {
 		"markdown-it-task-lists": "^2.1.1",
+		"medium-zoom": "^1.1.0",
 		"vitepress": "^1.2.3"
 	},
 	"scripts": {

docs/quick-start.md

@@ -47,12 +47,21 @@ services:
 
 ## 程序配置
 
-> [!NOTE]
-> 在 Docker 环境中，`~` 会被展开为 `/app`。
-
 你是否遇到了程序的 panic？别担心，这是正常情况。
 
-程序默认会将配置文件存储于 `~/.config/bili-sync/config.toml`，数据库文件存储于 `~/.config/bili-sync/data.sqlite`。
+程序默认会将配置文件存储于 `${config_dir}/bili-sync/config.toml`，数据库文件存储于 `${config_dir}/bili-sync/data.sqlite`。
+
+> [!CAUTION]
+>
+> 请注意，`config_dir` 的实际位置与操作系统和用户名有关。
+>
+> 对于名为 Alice 的用户，`config_dir` 指向的位置是：
+>
+> + Lin: `/home/Alice/.config`
+> + Win: `C:\Users\Alice\AppData\Roaming`
+> + Mac: `/Users/Alice/Library/Application Support`
+>
+> 特别的，在 Docker 环境中，`config_dir` 会被展开为 `/app/.config`。
 
 在启动时程序会尝试加载配置文件，如果发现不存在会新建并写入默认配置。
 
@@ -65,6 +74,7 @@ page_name = "{{bvid}}"
 interval = 1200
 upper_path = "/Users/amtoaer/Library/Application Support/bili-sync/upper_face"
 nfo_time_type = "favtime"
+time_format = "%Y-%m-%d"
 
 [credential]
 sessdata = ""
@@ -105,17 +115,23 @@ time_offset = 0.0
 [favorite_list]
 
 [collection_list]
+
+[submission_list]
+
+[watch_later]
+enabled = false
+path = ""
+
+[concurrent_limit]
+video = 3
+page = 2
+
+[concurrent_limit.rate_limit]
+limit = 4
+duration = 250
 ```
 
-看起来很长，但绝大部分选项是不需要做修改的。正常情况下，我们只需要关注：
-+ `interval`
-+ `upper_path`
-+ `credential`
-+ `codecs`
-+ `favorite_list`
-+ `collection_list`
-
-以下逐条说明。
+虽然配置文件看起来很长，但绝大部分选项是不需要做修改的。一般来说，我们只需要关注其中的少数几个，以下逐条说明。
 
 ### `interval`
 
@@ -161,6 +177,25 @@ UP 主头像和信息的保存位置。对于使用 Emby、Jellyfin 媒体服务
 
 具体说明可以参考[这里](/collection)。
 
+### `submission_list`
+
+你想要下载的 UP 主投稿与想要保存的位置。简单示例：
+```toml
+9183758 = "/home/amtoaer/Downloads/bili-sync/测试投稿"
+```
+UP 主 ID 的获取方式可以参考[这里](/submission)。
+
+### `watch_later`
+
+设置稍后再看的扫描开关与保存位置。
+
+如果你希望下载稍后再看列表中的视频，可以将 `enabled` 设置为 `true`，并填写 `path`。
+
+```toml
+enabled = true
+path = "/home/amtoaer/Downloads/bili-sync/稍后再看"
+```
+
 ## 运行
 
 在配置文件填写完毕后，我们可以直接运行程序。如果配置文件无误，程序会自动开始下载收藏夹中的视频。并每隔 `interval` 秒重新扫描一次。

docs/submission.md

@@ -0,0 +1,5 @@
+# 获取 UP 主信息
+
+UP 主 的 ID 获取也很简单，在网页端打开想要获取投稿的 UP 主首页，直接查看网址栏中的数字或页面中的个人信息即可。
+
+![image](./assets/submission.webp)

scripts/tools/compress_image.py

@@ -0,0 +1,35 @@
+"""
+供开发者使用的图片压缩工具，批量将项目中的图片压缩为 webp 格式
+"""
+
+import os
+
+
+def main():
+    for root, dirs, files in os.walk(".", topdown=True):
+        dirs[:] = [d for d in dirs if d != "dist" and not d.startswith(".")]
+        if all(dir_name not in root for dir_name in ("assets", "static", "public")):
+            continue
+        for file in files:
+            if "icon" in file or not file.endswith(("jpg", "jpeg", "png")):
+                continue
+            source, target = file, file[: file.rfind(".")] + ".webp"
+            escaped_source, escaped_target = (
+                source.replace(".", r"\."),
+                target.replace(".", r"\."),
+            )
+            source_path, target_path = (
+                os.path.join(root, source),
+                os.path.join(root, target),
+            )
+            os.system(
+                rf"""
+                cwebp -q 80 -sharp_yuv -mt -metadata all {source_path} -o {target_path} && \
+                rm {source_path} && \
+                rg {source} --files-with-matches --no-messages | xargs sed -i '' 's/{escaped_source}/{escaped_target}/g'
+                """
+            )
+
+
+if __name__ == "__main__":
+    main()