feat: 迁移所有配置到数据库，并支持运行时重载 (#364)

crates/bili_sync/src/adapter/collection.rs

@@ -90,50 +90,55 @@ impl VideoSource for collection::Model {
     fn log_download_video_end(&self) {
         info!("下载{}「{}」视频完成", CollectionType::from(self.r#type), self.name);
     }
-}
 
-pub(super) async fn collection_from<'a>(
-    collection_item: &'a CollectionItem,
-    path: &Path,
-    bili_client: &'a BiliClient,
-    connection: &DatabaseConnection,
-) -> Result<(
-    VideoSourceEnum,
-    Pin<Box<dyn Stream<Item = Result<VideoInfo>> + 'a + Send>>,
-)> {
-    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((
-        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?
-            .context("collection not found")?
-            .into(),
-        Box::pin(collection.into_video_stream()),
-    ))
+    async fn refresh<'a>(
+        self,
+        bili_client: &'a BiliClient,
+        connection: &'a DatabaseConnection,
+    ) -> Result<(
+        VideoSourceEnum,
+        Pin<Box<dyn Stream<Item = Result<VideoInfo>> + Send + 'a>>,
+    )> {
+        let collection = Collection::new(
+            bili_client,
+            CollectionItem {
+                sid: self.s_id.to_string(),
+                mid: self.m_id.to_string(),
+                collection_type: CollectionType::from(self.r#type),
+            },
+        );
+        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()),
+            ..Default::default()
+        })
+        .on_conflict(
+            OnConflict::columns([
+                collection::Column::SId,
+                collection::Column::MId,
+                collection::Column::Type,
+            ])
+            .update_column(collection::Column::Name)
+            .to_owned(),
+        )
+        .exec(connection)
+        .await?;
+        Ok((
+            collection::Entity::find()
+                .filter(
+                    collection::Column::SId
+                        .eq(self.s_id)
+                        .and(collection::Column::MId.eq(self.m_id))
+                        .and(collection::Column::Type.eq(self.r#type)),
+                )
+                .one(connection)
+                .await?
+                .context("collection not found")?
+                .into(),
+            Box::pin(collection.into_video_stream()),
+        ))
+    }
 }

crates/bili_sync/src/adapter/favorite.rs

@@ -60,39 +60,37 @@ impl VideoSource for favorite::Model {
     fn log_download_video_end(&self) {
         info!("下载收藏夹「{}」视频完成", self.name);
     }
-}
 
-pub(super) async fn favorite_from<'a>(
-    fid: &str,
-    path: &Path,
-    bili_client: &'a BiliClient,
-    connection: &DatabaseConnection,
-) -> Result<(
-    VideoSourceEnum,
-    Pin<Box<dyn Stream<Item = Result<VideoInfo>> + 'a + Send>>,
-)> {
-    let favorite = FavoriteList::new(bili_client, fid.to_owned());
-    let favorite_info = favorite.get_info().await?;
-    favorite::Entity::insert(favorite::ActiveModel {
-        f_id: Set(favorite_info.id),
-        name: Set(favorite_info.title.clone()),
-        path: Set(path.to_string_lossy().to_string()),
-        ..Default::default()
-    })
-    .on_conflict(
-        OnConflict::column(favorite::Column::FId)
-            .update_columns([favorite::Column::Name, favorite::Column::Path])
-            .to_owned(),
-    )
-    .exec(connection)
-    .await?;
-    Ok((
-        favorite::Entity::find()
-            .filter(favorite::Column::FId.eq(favorite_info.id))
-            .one(connection)
-            .await?
-            .context("favorite not found")?
-            .into(),
-        Box::pin(favorite.into_video_stream()),
-    ))
+    async fn refresh<'a>(
+        self,
+        bili_client: &'a BiliClient,
+        connection: &'a DatabaseConnection,
+    ) -> Result<(
+        VideoSourceEnum,
+        Pin<Box<dyn Stream<Item = Result<VideoInfo>> + Send + 'a>>,
+    )> {
+        let favorite = FavoriteList::new(bili_client, self.f_id.to_string());
+        let favorite_info = favorite.get_info().await?;
+        favorite::Entity::insert(favorite::ActiveModel {
+            f_id: Set(favorite_info.id),
+            name: Set(favorite_info.title.clone()),
+            ..Default::default()
+        })
+        .on_conflict(
+            OnConflict::column(favorite::Column::FId)
+                .update_column(favorite::Column::Name)
+                .to_owned(),
+        )
+        .exec(connection)
+        .await?;
+        Ok((
+            favorite::Entity::find()
+                .filter(favorite::Column::FId.eq(favorite_info.id))
+                .one(connection)
+                .await?
+                .context("favorite not found")?
+                .into(),
+            Box::pin(favorite.into_video_stream()),
+        ))
+    }
 }

crates/bili_sync/src/adapter/mod.rs

@@ -20,11 +20,7 @@ use bili_sync_entity::favorite::Model as Favorite;
 use bili_sync_entity::submission::Model as Submission;
 use bili_sync_entity::watch_later::Model as WatchLater;
 
-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::{BiliClient, CollectionItem, VideoInfo};
+use crate::bilibili::{BiliClient, VideoInfo};
 
 #[enum_dispatch]
 pub enum VideoSourceEnum {
@@ -84,31 +80,15 @@ pub trait VideoSource {
 
     /// 结束下载视频
     fn log_download_video_end(&self);
-}
 
-#[derive(Clone, Copy, Debug)]
-pub enum Args<'a> {
-    Favorite { fid: &'a str },
-    Collection { collection_item: &'a CollectionItem },
-    WatchLater,
-    Submission { upper_id: &'a str },
-}
-
-pub async fn video_source_from<'a>(
-    args: Args<'a>,
-    path: &Path,
-    bili_client: &'a BiliClient,
-    connection: &DatabaseConnection,
-) -> Result<(
-    VideoSourceEnum,
-    Pin<Box<dyn Stream<Item = Result<VideoInfo>> + 'a + Send>>,
-)> {
-    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 fn refresh<'a>(
+        self,
+        bili_client: &'a BiliClient,
+        connection: &'a DatabaseConnection,
+    ) -> Result<(
+        VideoSourceEnum,
+        Pin<Box<dyn Stream<Item = Result<VideoInfo>> + Send + 'a>>,
+    )>;
 }
 
 pub enum _ActiveModel {

crates/bili_sync/src/adapter/submission.rs

@@ -60,39 +60,37 @@ impl VideoSource for submission::Model {
     fn log_download_video_end(&self) {
         info!("下载「{}」投稿视频完成", self.upper_name);
     }
-}
 
-pub(super) async fn submission_from<'a>(
-    upper_id: &str,
-    path: &Path,
-    bili_client: &'a BiliClient,
-    connection: &DatabaseConnection,
-) -> Result<(
-    VideoSourceEnum,
-    Pin<Box<dyn Stream<Item = Result<VideoInfo>> + 'a + Send>>,
-)> {
-    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((
-        submission::Entity::find()
-            .filter(submission::Column::UpperId.eq(upper.mid))
-            .one(connection)
-            .await?
-            .context("submission not found")?
-            .into(),
-        Box::pin(submission.into_video_stream()),
-    ))
+    async fn refresh<'a>(
+        self,
+        bili_client: &'a BiliClient,
+        connection: &'a DatabaseConnection,
+    ) -> Result<(
+        VideoSourceEnum,
+        Pin<Box<dyn Stream<Item = Result<VideoInfo>> + Send + 'a>>,
+    )> {
+        let submission = Submission::new(bili_client, self.upper_id.to_string());
+        let upper = submission.get_info().await?;
+        submission::Entity::insert(submission::ActiveModel {
+            upper_id: Set(upper.mid.parse()?),
+            upper_name: Set(upper.name),
+            ..Default::default()
+        })
+        .on_conflict(
+            OnConflict::column(submission::Column::UpperId)
+                .update_column(submission::Column::UpperName)
+                .to_owned(),
+        )
+        .exec(connection)
+        .await?;
+        Ok((
+            submission::Entity::find()
+                .filter(submission::Column::UpperId.eq(upper.mid))
+                .one(connection)
+                .await?
+                .context("submission not found")?
+                .into(),
+            Box::pin(submission.into_video_stream()),
+        ))
+    }
 }

crates/bili_sync/src/adapter/watch_later.rs

@@ -1,12 +1,12 @@
 use std::path::Path;
 use std::pin::Pin;
 
-use anyhow::{Context, Result};
+use anyhow::Result;
 use bili_sync_entity::*;
 use futures::Stream;
 use sea_orm::ActiveValue::Set;
 use sea_orm::entity::prelude::*;
-use sea_orm::sea_query::{OnConflict, SimpleExpr};
+use sea_orm::sea_query::SimpleExpr;
 use sea_orm::{DatabaseConnection, Unchanged};
 
 use crate::adapter::{_ActiveModel, VideoSource, VideoSourceEnum};
@@ -60,36 +60,16 @@ impl VideoSource for watch_later::Model {
     fn log_download_video_end(&self) {
         info!("下载稍后再看视频完成");
     }
-}
 
-pub(super) async fn watch_later_from<'a>(
-    path: &Path,
-    bili_client: &'a BiliClient,
-    connection: &DatabaseConnection,
-) -> Result<(
-    VideoSourceEnum,
-    Pin<Box<dyn Stream<Item = Result<VideoInfo>> + 'a + Send>>,
-)> {
-    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((
-        watch_later::Entity::find()
-            .filter(watch_later::Column::Id.eq(1))
-            .one(connection)
-            .await?
-            .context("watch_later not found")?
-            .into(),
-        Box::pin(watch_later.into_video_stream()),
-    ))
+    async fn refresh<'a>(
+        self,
+        bili_client: &'a BiliClient,
+        _connection: &'a DatabaseConnection,
+    ) -> Result<(
+        VideoSourceEnum,
+        Pin<Box<dyn Stream<Item = Result<VideoInfo>> + Send + 'a>>,
+    )> {
+        let watch_later = WatchLater::new(bili_client);
+        Ok((self.into(), Box::pin(watch_later.into_video_stream())))
+    }
 }