266 lines
8.7 KiB
Rust
266 lines
8.7 KiB
Rust
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>,
|
|
#[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,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Default)]
|
|
pub struct WatchLaterConfig {
|
|
pub enabled: bool,
|
|
pub path: PathBuf,
|
|
}
|
|
|
|
#[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(),
|
|
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,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Config {
|
|
/// 简单的预检查
|
|
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 !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,
|
|
}
|