refactor: 重构部分代码，调整函数位置 (#154)

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 crate::adapter::{error_fetch_video_detail, VideoListModel};
+use crate::adapter::{helper, VideoListModel};
 use crate::bilibili::{self, BiliClient, Collection, CollectionItem, CollectionType, VideoInfo};
-use crate::config::TEMPLATE;
-use crate::utils::id_time_key;
-use crate::utils::model::create_video_pages;
 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,37 +57,13 @@ 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::Pubtime])
-            .into_tuple()
-            .all(connection)
-            .await?
-            .into_iter()
-            .map(|(bvid, time)| id_time_key(&bvid, &time))
-            .collect::<HashSet<_>>())
+        helper::video_keys(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(
@@ -156,7 +80,7 @@ impl VideoListModel for collection::Model {
                 };
                 let txn = connection.begin().await?;
                 // 将分页信息写入数据库
-                create_video_pages(pages, &video_model, &txn).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));
@@ -165,7 +89,7 @@ impl VideoListModel for collection::Model {
                 txn.commit().await?;
             }
             Err(e) => {
-                error_fetch_video_detail(e, video_model, connection).await?;
+                helper::error_fetch_video_detail(e, video_model, connection).await?;
             }
         };
         Ok(())
@@ -227,3 +151,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()),
+    ))
+}