129 lines
4.3 KiB
Rust
129 lines
4.3 KiB
Rust
use std::collections::HashSet;
|
|
use std::path::Path;
|
|
use std::sync::Arc;
|
|
|
|
use entity::*;
|
|
use futures_util::{pin_mut, StreamExt};
|
|
use migration::OnConflict;
|
|
use sea_orm::entity::prelude::*;
|
|
use sea_orm::ActiveValue::Set;
|
|
use sea_orm::QuerySelect;
|
|
|
|
use crate::bilibili::{BiliClient, FavoriteList, FavoriteListInfo, VideoInfo};
|
|
use crate::Result;
|
|
|
|
pub async fn process_favorite(
|
|
bili_client: Arc<BiliClient>,
|
|
fid: i32,
|
|
connection: Arc<DatabaseConnection>,
|
|
) -> Result<()> {
|
|
let favorite_list = FavoriteList::new(bili_client.clone(), fid.to_string());
|
|
let info = favorite_list.get_info().await?;
|
|
let favorite_obj = handle_favorite_info(&info, connection.as_ref()).await?;
|
|
println!(
|
|
"Hi there! I'm going to scan this favorite: {:?}",
|
|
favorite_obj
|
|
);
|
|
let video_stream = favorite_list.into_video_stream().chunks(10);
|
|
pin_mut!(video_stream);
|
|
while let Some(videos_info) = video_stream.next().await {
|
|
let exist_bvids_pubtimes =
|
|
exists_bvids_favtime(&videos_info, fid, connection.as_ref()).await?;
|
|
let video_info_to_create = videos_info
|
|
.iter()
|
|
.filter(|v| !exist_bvids_pubtimes.contains(&(v.bvid.clone(), v.fav_time.to_string())))
|
|
.collect::<Vec<&VideoInfo>>();
|
|
let len = video_info_to_create.len();
|
|
if !video_info_to_create.is_empty() {
|
|
create_videos(video_info_to_create, &favorite_obj, connection.as_ref()).await?;
|
|
}
|
|
if videos_info.len() != len {
|
|
break;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
// 根据获得的收藏夹信息，插入或更新数据库中的收藏夹，并返回收藏夹对象
|
|
async fn handle_favorite_info(
|
|
info: &FavoriteListInfo,
|
|
connection: &DatabaseConnection,
|
|
) -> Result<favorite::Model> {
|
|
Ok(favorite::Entity::insert(favorite::ActiveModel {
|
|
f_id: Set(info.id as i32),
|
|
name: Set(info.title.to_string()),
|
|
path: Set("/home/amtoaer/Documents/code/rust/bili-sync/video".to_string()),
|
|
enabled: Set(true),
|
|
..Default::default()
|
|
})
|
|
.on_conflict(
|
|
OnConflict::column(favorite::Column::FId)
|
|
.update_column(favorite::Column::Name)
|
|
.update_column(favorite::Column::Path)
|
|
.update_column(favorite::Column::Enabled)
|
|
.to_owned(),
|
|
)
|
|
.exec_with_returning(connection)
|
|
.await?)
|
|
}
|
|
|
|
// 获取数据库中存在的与该视频 favorite_id 和 bvid 重合的视频
|
|
async fn exists_bvids_favtime(
|
|
videos_info: &[VideoInfo],
|
|
fid: i32,
|
|
connection: &DatabaseConnection,
|
|
) -> Result<HashSet<(String, String)>> {
|
|
let bvids = videos_info
|
|
.iter()
|
|
.map(|v| v.bvid.clone())
|
|
.collect::<Vec<String>>();
|
|
let exist_bvid_favtime = video::Entity::find()
|
|
.filter(
|
|
video::Column::FavoriteId
|
|
.eq(fid)
|
|
.and(video::Column::Bvid.is_in(bvids)),
|
|
)
|
|
.select_only()
|
|
.columns([video::Column::Bvid, video::Column::Favtime])
|
|
.all(connection)
|
|
.await?
|
|
.into_iter()
|
|
.map(|v| (v.bvid, v.favtime))
|
|
.collect::<HashSet<(String, String)>>();
|
|
Ok(exist_bvid_favtime)
|
|
}
|
|
|
|
async fn create_videos(
|
|
videos_info: Vec<&VideoInfo>,
|
|
favorite_obj: &favorite::Model,
|
|
connection: &DatabaseConnection,
|
|
) -> Result<u64> {
|
|
let video_models = videos_info
|
|
.iter()
|
|
.map(move |v| video::ActiveModel {
|
|
favorite_id: Set(favorite_obj.id),
|
|
bvid: Set(v.bvid.clone()),
|
|
path: Set(Path::new(favorite_obj.path.as_str())
|
|
.join(&v.title)
|
|
.to_str()
|
|
.unwrap()
|
|
.to_string()),
|
|
name: Set(v.title.clone()),
|
|
category: Set(v.vtype.to_string()),
|
|
intro: Set(v.intro.clone()),
|
|
cover: Set(v.cover.clone()),
|
|
ctime: Set(v.ctime.to_string()),
|
|
pubtime: Set(v.pubtime.to_string()),
|
|
favtime: Set(v.fav_time.to_string()),
|
|
downloaded: Set(false),
|
|
valid: Set(true),
|
|
tags: Set("[]".to_string()),
|
|
single_page: Set(false),
|
|
..Default::default()
|
|
})
|
|
.collect::<Vec<video::ActiveModel>>();
|
|
Ok(video::Entity::insert_many(video_models)
|
|
.exec_without_returning(connection)
|
|
.await?)
|
|
}
|