refactor: extract media unlock checker crate

This commit is contained in:
Tunglies
2026-08-04 11:37:54 +08:00
parent 544c47c634
commit a8275b20b7
19 changed files with 160 additions and 117 deletions
@@ -1,102 +0,0 @@
use std::sync::Arc;
use clash_verge_logging::{Type, logging};
use regex::Regex;
use reqwest::{Client, cookie::Jar};
use super::UnlockItem;
pub(super) async fn check_bahamut_anime(client: &Client) -> UnlockItem {
let cookie_store = Arc::new(Jar::default());
let client_with_cookies = match Client::builder()
.use_rustls_tls()
.user_agent(
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
)
.cookie_provider(Arc::clone(&cookie_store))
.build()
{
Ok(client) => client,
Err(e) => {
logging!(
error,
Type::Network,
"Failed to create client with cookies for Bahamut Anime: {}",
e
);
client.clone()
}
};
let device_url = "https://ani.gamer.com.tw/ajax/getdeviceid.php";
let device_id = match client_with_cookies.get(device_url).send().await {
Ok(response) => match response.text().await {
Ok(text) => match Regex::new(r#""deviceid"\s*:\s*"([^"]+)"#) {
Ok(re) => re
.captures(&text)
.and_then(|caps| caps.get(1).map(|m| m.as_str().to_string()))
.unwrap_or_default(),
Err(e) => {
logging!(
error,
Type::Network,
"Failed to compile deviceid regex for Bahamut Anime: {}",
e
);
String::new()
}
},
Err(_) => String::new(),
},
Err(_) => String::new(),
};
if device_id.is_empty() {
return UnlockItem::checked("Bahamut Anime", "Failed", None);
}
let url = format!("https://ani.gamer.com.tw/ajax/token.php?adID=89422&sn=37783&device={device_id}");
let token_result = match client_with_cookies.get(&url).send().await {
Ok(response) => match response.text().await {
Ok(body) => {
if body.contains("animeSn") {
Some(body)
} else {
None
}
}
Err(_) => None,
},
Err(_) => None,
};
if token_result.is_none() {
return UnlockItem::checked("Bahamut Anime", "No", None);
}
let region = match client_with_cookies.get("https://ani.gamer.com.tw/").send().await {
Ok(response) => match response.text().await {
Ok(body) => match Regex::new(r#"data-geo="([^"]+)"#) {
Ok(region_re) => region_re.captures(&body).and_then(|caps| caps.get(1)).map(|m| {
let country_code = m.as_str();
UnlockItem::region_label(country_code)
}),
Err(e) => {
logging!(
error,
Type::Network,
"Failed to compile region regex for Bahamut Anime: {}",
e
);
None
}
},
Err(_) => None,
},
Err(_) => None,
};
UnlockItem::checked("Bahamut Anime", "Yes", region)
}
@@ -1,60 +0,0 @@
use reqwest::Client;
use serde_json::Value;
use super::UnlockItem;
pub(super) async fn check_bilibili_china_mainland(client: &Client) -> UnlockItem {
let url = "https://api.bilibili.com/pgc/player/web/playurl?avid=82846771&qn=0&type=&otype=json&ep_id=307247&fourk=1&fnver=0&fnval=16&module=bangumi";
match client.get(url).send().await {
Ok(response) => match response.json::<Value>().await {
Ok(body) => {
let status = body
.get("code")
.and_then(|v| v.as_i64())
.map(|code| {
if code == 0 {
"Yes"
} else if code == -10403 {
"No"
} else {
"Failed"
}
})
.unwrap_or("Failed");
UnlockItem::checked("哔哩哔哩大陆", status, None)
}
Err(_) => UnlockItem::checked("哔哩哔哩大陆", "Failed", None),
},
Err(_) => UnlockItem::checked("哔哩哔哩大陆", "Failed", None),
}
}
pub(super) async fn check_bilibili_hk_mc_tw(client: &Client) -> UnlockItem {
let url = "https://api.bilibili.com/pgc/player/web/playurl?avid=18281381&cid=29892777&qn=0&type=&otype=json&ep_id=183799&fourk=1&fnver=0&fnval=16&module=bangumi";
match client.get(url).send().await {
Ok(response) => match response.json::<Value>().await {
Ok(body) => {
let status = body
.get("code")
.and_then(|v| v.as_i64())
.map(|code| {
if code == 0 {
"Yes"
} else if code == -10403 {
"No"
} else {
"Failed"
}
})
.unwrap_or("Failed");
UnlockItem::checked("哔哩哔哩港澳台", status, None)
}
Err(_) => UnlockItem::checked("哔哩哔哩港澳台", "Failed", None),
},
Err(_) => UnlockItem::checked("哔哩哔哩港澳台", "Failed", None),
}
}
@@ -1,80 +0,0 @@
use std::collections::HashMap;
use reqwest::Client;
use super::UnlockItem;
pub(super) async fn check_chatgpt_combined(client: &Client) -> Vec<UnlockItem> {
let mut results = Vec::new();
let url_country = "https://chat.openai.com/cdn-cgi/trace";
let result_country = client.get(url_country).send().await;
let region = match result_country {
Ok(response) => {
if let Ok(body) = response.text().await {
let mut map = HashMap::new();
for line in body.lines() {
if let Some(index) = line.find('=') {
let key = &line[..index];
let value = &line[index + 1..];
map.insert(key.to_string(), value.to_string());
}
}
map.get("loc").map(|loc| UnlockItem::region_label(loc))
} else {
None
}
}
Err(_) => None,
};
let url_ios = "https://ios.chat.openai.com/";
let result_ios = client.get(url_ios).send().await;
let ios_status = match result_ios {
Ok(response) => {
if let Ok(body) = response.text().await {
let body_lower = body.to_lowercase();
if body_lower.contains("you may be connected to a disallowed isp") {
"Disallowed ISP"
} else if body_lower.contains("request is not allowed. please try again later.") {
"Yes"
} else if body_lower.contains("sorry, you have been blocked") {
"Blocked"
} else {
"Failed"
}
} else {
"Failed"
}
}
Err(_) => "Failed",
};
let url_web = "https://api.openai.com/compliance/cookie_requirements";
let result_web = client.get(url_web).send().await;
let web_status = match result_web {
Ok(response) => {
if let Ok(body) = response.text().await {
let body_lower = body.to_lowercase();
if body_lower.contains("unsupported_country") {
"Unsupported Country/Region"
} else {
"Yes"
}
} else {
"Failed"
}
}
Err(_) => "Failed",
};
results.push(UnlockItem::checked("ChatGPT iOS", ios_status, region.clone()));
results.push(UnlockItem::checked("ChatGPT Web", web_status, region));
results
}
@@ -1,38 +0,0 @@
use reqwest::Client;
use super::UnlockItem;
const BLOCKED_CODES: [&str; 10] = ["AF", "BY", "CN", "CU", "HK", "IR", "KP", "MO", "RU", "SY"];
pub(super) async fn check_claude(client: &Client) -> UnlockItem {
let url = "https://claude.ai/cdn-cgi/trace";
match client.get(url).send().await {
Ok(response) => match response.text().await {
Ok(body) => {
let mut country_code: Option<String> = None;
for line in body.lines() {
if let Some(rest) = line.strip_prefix("loc=") {
country_code = Some(rest.trim().to_uppercase());
break;
}
}
if let Some(code) = country_code {
let status = if BLOCKED_CODES.contains(&code.as_str()) {
"No"
} else {
"Yes"
};
UnlockItem::checked_region("Claude", status, &code)
} else {
UnlockItem::checked("Claude", "Failed", None)
}
}
Err(_) => UnlockItem::checked("Claude", "Failed", None),
},
Err(_) => UnlockItem::checked("Claude", "Failed", None),
}
}
@@ -1,306 +0,0 @@
use regex::Regex;
use reqwest::Client;
use clash_verge_logging::{Type, logging};
use super::UnlockItem;
const DISNEY_PLUS: &str = "Disney+";
const AUTH_HEADER: &str = "Bearer ZGlzbmV5JmJyb3dzZXImMS4wLjA.Cu56AgSfBTDag5NiRA81oLHkDZfu5L3CKadnefEAY84";
fn disney_item(status: impl Into<String>, region: Option<String>) -> UnlockItem {
UnlockItem::checked(DISNEY_PLUS, status, region)
}
async fn fetch_main_page_region(client: &Client) -> Option<String> {
let body = client
.get("https://www.disneyplus.com/")
.send()
.await
.ok()?
.text()
.await
.ok()?;
let region_re = match Regex::new(r#"region"\s*:\s*"([^"]+)"#) {
Ok(region_re) => region_re,
Err(e) => {
logging!(
error,
Type::Network,
"Failed to compile Disney+ main page region regex: {}",
e
);
return None;
}
};
region_re
.captures(&body)
.and_then(|caps| caps.get(1).map(|m| m.as_str().to_string()))
}
async fn disney_region_from_main_page(client: &Client) -> Option<UnlockItem> {
let region = fetch_main_page_region(client).await?;
Some(disney_item(
"Yes",
Some(format!("{} (from main page)", UnlockItem::region_label(&region))),
))
}
#[allow(clippy::cognitive_complexity)]
pub(super) async fn check_disney_plus(client: &Client) -> UnlockItem {
let device_api_url = "https://disney.api.edge.bamgrid.com/devices";
let device_req_body = serde_json::json!({
"deviceFamily": "browser",
"applicationRuntime": "chrome",
"deviceProfile": "windows",
"attributes": {}
});
let device_result = client
.post(device_api_url)
.header("authorization", AUTH_HEADER)
.header("content-type", "application/json; charset=UTF-8")
.json(&device_req_body)
.send()
.await;
let device_response = match device_result {
Ok(response) => response,
Err(_) => {
return disney_item("Failed (Network Connection)", None);
}
};
if device_response.status().as_u16() == 403 {
return disney_item("No (IP Banned By Disney+)", None);
}
let device_body = match device_response.text().await {
Ok(body) => body,
Err(_) => {
return disney_item("Failed (Error: Cannot read response)", None);
}
};
let re = match Regex::new(r#""assertion"\s*:\s*"([^"]+)"#) {
Ok(re) => re,
Err(e) => {
logging!(
error,
Type::Network,
"Failed to compile assertion regex for Disney+: {}",
e
);
return disney_item("Failed (Regex Error)", None);
}
};
let assertion = match re.captures(&device_body) {
Some(caps) => caps.get(1).map(|m| m.as_str().to_string()),
None => None,
};
if assertion.is_none() {
return disney_item("Failed (Error: Cannot extract assertion)", None);
}
let token_url = "https://disney.api.edge.bamgrid.com/token";
let assertion_str = assertion.unwrap_or_default();
let token_body = [
("grant_type", "urn:ietf:params:oauth:grant-type:token-exchange"),
("latitude", "0"),
("longitude", "0"),
("platform", "browser"),
("subject_token", assertion_str.as_str()),
("subject_token_type", "urn:bamtech:params:oauth:token-type:device"),
];
let token_result = client
.post(token_url)
.header("authorization", AUTH_HEADER)
.header("content-type", "application/x-www-form-urlencoded")
.form(&token_body)
.send()
.await;
let token_response = match token_result {
Ok(response) => response,
Err(_) => {
return disney_item("Failed (Network Connection)", None);
}
};
let token_status = token_response.status();
let token_body_text = match token_response.text().await {
Ok(body) => body,
Err(_) => {
return disney_item("Failed (Error: Cannot read token response)", None);
}
};
if token_body_text.contains("forbidden-location") || token_body_text.contains("403 ERROR") {
return disney_item("No (IP Banned By Disney+)", None);
}
let token_json: Result<serde_json::Value, _> = serde_json::from_str(&token_body_text);
let refresh_token = match token_json {
Ok(json) => json
.get("refresh_token")
.and_then(|v| v.as_str())
.map(|s| s.to_string()),
Err(_) => match Regex::new(r#""refresh_token"\s*:\s*"([^"]+)"#) {
Ok(refresh_token_re) => refresh_token_re
.captures(&token_body_text)
.and_then(|caps| caps.get(1).map(|m| m.as_str().to_string())),
Err(e) => {
logging!(
error,
Type::Network,
"Failed to compile refresh_token regex for Disney+: {}",
e
);
None
}
},
};
if refresh_token.is_none() {
return disney_item(
format!(
"Failed (Error: Cannot extract refresh token, status: {}, response: {})",
token_status.as_u16(),
token_body_text.chars().take(100).collect::<String>() + "..."
),
None,
);
}
let graphql_url = "https://disney.api.edge.bamgrid.com/graph/v1/device/graphql";
let graphql_payload = format!(
r#"{{"query":"mutation refreshToken($input: RefreshTokenInput!) {{ refreshToken(refreshToken: $input) {{ activeSession {{ sessionId }} }} }}","variables":{{"input":{{"refreshToken":"{}"}}}}}}"#,
refresh_token.unwrap_or_default()
);
let graphql_result = client
.post(graphql_url)
.header("authorization", AUTH_HEADER)
.header("content-type", "application/json")
.body(graphql_payload)
.send()
.await;
let preview_check = client.get("https://disneyplus.com").send().await;
let is_unavailable = match preview_check {
Ok(response) => {
let url = response.url().to_string();
url.contains("preview") || url.contains("unavailable")
}
Err(_) => true,
};
let graphql_response = match graphql_result {
Ok(response) => response,
Err(_) => {
return disney_item("Failed (Network Connection)", None);
}
};
let graphql_status = graphql_response.status();
let graphql_body_text = match graphql_response.text().await {
Ok(text) => text,
Err(e) => {
logging!(
error,
Type::Network,
"Failed to read Disney+ GraphQL response text: {}",
e
);
String::new()
}
};
if graphql_body_text.is_empty() || graphql_status.as_u16() >= 400 {
if let Some(item) = disney_region_from_main_page(client).await {
return item;
}
if graphql_body_text.is_empty() {
return disney_item(
format!(
"Failed (GraphQL error: empty response, status: {})",
graphql_status.as_u16()
),
None,
);
}
return disney_item(
format!(
"Failed (GraphQL error: {}, status: {})",
graphql_body_text.chars().take(50).collect::<String>() + "...",
graphql_status.as_u16()
),
None,
);
}
let region_re = match Regex::new(r#""countryCode"\s*:\s*"([^"]+)"#) {
Ok(re) => re,
Err(e) => {
logging!(
error,
Type::Network,
"Failed to compile Disney+ countryCode regex: {}",
e
);
return disney_item("Failed (Regex Error)", None);
}
};
let region_code = region_re
.captures(&graphql_body_text)
.and_then(|caps| caps.get(1).map(|m| m.as_str().to_string()));
let supported_re = match Regex::new(r#""inSupportedLocation"\s*:\s*(false|true)"#) {
Ok(re) => re,
Err(e) => {
logging!(
error,
Type::Network,
"Failed to compile Disney+ supported location regex: {}",
e
);
return disney_item("Failed (Regex Error)", None);
}
};
let in_supported_location = supported_re
.captures(&graphql_body_text)
.and_then(|caps| caps.get(1).map(|m| m.as_str() == "true"));
if region_code.is_none() {
if let Some(item) = disney_region_from_main_page(client).await {
return item;
}
return disney_item("No", None);
}
let region = region_code.unwrap_or_default();
if region == "JP" {
return UnlockItem::checked_region(DISNEY_PLUS, "Yes", &region);
}
if is_unavailable {
return disney_item("No", None);
}
match in_supported_location {
Some(false) => disney_item(
"Soon",
Some(format!("{}(即将上线)", UnlockItem::region_label(&region))),
),
Some(true) => UnlockItem::checked_region(DISNEY_PLUS, "Yes", &region),
None => disney_item(format!("Failed (Error: Unknown region status for {region})"), None),
}
}
@@ -1,36 +0,0 @@
use reqwest::Client;
use super::UnlockItem;
const BLOCKED_CODES: [&str; 9] = ["CHN", "RUS", "BLR", "CUB", "IRN", "PRK", "SYR", "HKG", "MAC"];
const REGION_MARKER: &str = ",2,1,200,\"";
pub(super) async fn check_gemini(client: &Client) -> UnlockItem {
let url = "https://gemini.google.com";
let failed = || UnlockItem::checked("Gemini", "Failed", None);
let response = match client.get(url).send().await {
Ok(r) => r,
Err(_) => return failed(),
};
let body = match response.text().await {
Ok(b) => b,
Err(_) => return failed(),
};
let country_code = body
.find(REGION_MARKER)
.and_then(|i| {
let start = i + REGION_MARKER.len();
body.get(start..start + 3)
})
.filter(|s| s.bytes().all(|b| b.is_ascii_uppercase()));
match country_code {
Some(code) => {
let status = if BLOCKED_CODES.contains(&code) { "No" } else { "Yes" };
UnlockItem::checked_region("Gemini", status, code)
}
None => failed(),
}
}
+3 -111
View File
@@ -1,120 +1,12 @@
use std::{future::Future, sync::Arc};
use reqwest::Client;
pub use clash_verge_media_unlock::UnlockItem;
use tauri::command;
use tokio::task::JoinSet;
use clash_verge_logging::{Type, logging};
mod bahamut;
mod bilibili;
mod chatgpt;
mod claude;
mod disney_plus;
mod gemini;
mod netflix;
mod prime_video;
mod spotify;
mod tiktok;
mod types;
mod utils;
mod youtube;
pub use types::UnlockItem;
use bahamut::check_bahamut_anime;
use bilibili::{check_bilibili_china_mainland, check_bilibili_hk_mc_tw};
use chatgpt::check_chatgpt_combined;
use claude::check_claude;
use disney_plus::check_disney_plus;
use gemini::check_gemini;
use netflix::check_netflix;
use prime_video::check_prime_video;
use spotify::check_spotify;
use tiktok::check_tiktok;
use youtube::check_youtube_premium;
type UnlockResults = Vec<UnlockItem>;
fn spawn_unlock_check<F, Fut>(tasks: &mut JoinSet<UnlockResults>, client: Arc<Client>, check: F)
where
F: FnOnce(Arc<Client>) -> Fut + Send + 'static,
Fut: Future<Output = UnlockResults> + Send + 'static,
{
tasks.spawn(async move { check(client).await });
}
fn single_result(item: UnlockItem) -> UnlockResults {
vec![item]
}
#[command]
pub async fn get_unlock_items() -> Result<Vec<UnlockItem>, String> {
Ok(types::default_unlock_items())
Ok(clash_verge_media_unlock::default_unlock_items())
}
#[command]
pub async fn check_media_unlock() -> Result<Vec<UnlockItem>, String> {
let client = match Client::builder()
.use_rustls_tls()
.user_agent("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36")
.timeout(std::time::Duration::from_secs(30))
.danger_accept_invalid_certs(true)
.danger_accept_invalid_hostnames(true)
.tcp_keepalive(std::time::Duration::from_secs(60))
.connection_verbose(true)
.build() {
Ok(client) => client,
Err(e) => return Err(format!("创建HTTP客户端失败: {e}")),
};
let mut tasks = JoinSet::new();
let client_arc = Arc::new(client);
spawn_unlock_check(&mut tasks, Arc::clone(&client_arc), |client| async move {
single_result(check_bilibili_china_mainland(&client).await)
});
spawn_unlock_check(&mut tasks, Arc::clone(&client_arc), |client| async move {
single_result(check_bilibili_hk_mc_tw(&client).await)
});
spawn_unlock_check(&mut tasks, Arc::clone(&client_arc), |client| async move {
check_chatgpt_combined(&client).await
});
spawn_unlock_check(&mut tasks, Arc::clone(&client_arc), |client| async move {
single_result(check_claude(&client).await)
});
spawn_unlock_check(&mut tasks, Arc::clone(&client_arc), |client| async move {
single_result(check_gemini(&client).await)
});
spawn_unlock_check(&mut tasks, Arc::clone(&client_arc), |client| async move {
single_result(check_youtube_premium(&client).await)
});
spawn_unlock_check(&mut tasks, Arc::clone(&client_arc), |client| async move {
single_result(check_bahamut_anime(&client).await)
});
spawn_unlock_check(&mut tasks, Arc::clone(&client_arc), |client| async move {
single_result(check_netflix(&client).await)
});
spawn_unlock_check(&mut tasks, Arc::clone(&client_arc), |client| async move {
single_result(check_disney_plus(&client).await)
});
spawn_unlock_check(&mut tasks, Arc::clone(&client_arc), |client| async move {
single_result(check_spotify(&client).await)
});
spawn_unlock_check(&mut tasks, Arc::clone(&client_arc), |client| async move {
single_result(check_tiktok(&client).await)
});
spawn_unlock_check(&mut tasks, Arc::clone(&client_arc), |client| async move {
single_result(check_prime_video(&client).await)
});
let mut results = Vec::new();
while let Some(res) = tasks.join_next().await {
match res {
Ok(items) => results.extend(items),
Err(e) => logging!(error, Type::Network, "任务执行失败: {e}"),
}
}
Ok(results)
clash_verge_media_unlock::check_media_unlock().await
}
@@ -1,132 +0,0 @@
use reqwest::Client;
use serde_json::Value;
use clash_verge_logging::{Type, logging};
use super::UnlockItem;
const NETFLIX: &str = "Netflix";
fn netflix_item(status: impl Into<String>, region: Option<String>) -> UnlockItem {
UnlockItem::checked(NETFLIX, status, region)
}
pub(super) async fn check_netflix(client: &Client) -> UnlockItem {
let cdn_result = check_netflix_cdn(client).await;
if cdn_result.status == "Yes" {
return cdn_result;
}
let url1 = "https://www.netflix.com/title/81280792";
let url2 = "https://www.netflix.com/title/70143836";
let result1 = client
.get(url1)
.timeout(std::time::Duration::from_secs(30))
.send()
.await;
if let Err(e) = &result1 {
logging!(error, Type::Network, "Netflix请求错误: {e}");
return netflix_item("Failed", None);
}
let result2 = client
.get(url2)
.timeout(std::time::Duration::from_secs(30))
.send()
.await;
if let Err(e) = &result2 {
logging!(error, Type::Network, "Netflix请求错误: {e}");
return netflix_item("Failed", None);
}
let status1 = match result1 {
Ok(response) => response.status().as_u16(),
Err(e) => {
logging!(error, Type::Network, "Failed to get Netflix response 1: {}", e);
return netflix_item("Failed", None);
}
};
let status2 = match result2 {
Ok(response) => response.status().as_u16(),
Err(e) => {
logging!(error, Type::Network, "Failed to get Netflix response 2: {}", e);
return netflix_item("Failed", None);
}
};
if status1 == 404 && status2 == 404 {
return netflix_item("Originals Only", None);
}
if status1 == 403 || status2 == 403 {
return netflix_item("No", None);
}
if status1 == 200 || status1 == 301 || status2 == 200 || status2 == 301 {
let test_url = "https://www.netflix.com/title/80018499";
match client
.get(test_url)
.timeout(std::time::Duration::from_secs(30))
.send()
.await
{
Ok(response) => {
if let Some(location) = response.headers().get("location")
&& let Ok(location_str) = location.to_str()
{
let parts: Vec<&str> = location_str.split('/').collect();
if parts.len() >= 4 {
let region_code = parts[3].split('-').next().unwrap_or("unknown");
return UnlockItem::checked_region(NETFLIX, "Yes", region_code);
}
}
UnlockItem::checked_region(NETFLIX, "Yes", "us")
}
Err(e) => {
logging!(error, Type::Network, "获取Netflix区域信息失败: {e}");
netflix_item("Yes (但无法获取区域)", None)
}
}
} else {
netflix_item(format!("Failed (状态码: {status1}_{status2}"), None)
}
}
async fn check_netflix_cdn(client: &Client) -> UnlockItem {
let url = "https://api.fast.com/netflix/speedtest/v2?https=true&token=YXNkZmFzZGxmbnNkYWZoYXNkZmhrYWxm&urlCount=5";
match client.get(url).timeout(std::time::Duration::from_secs(30)).send().await {
Ok(response) => {
if response.status().as_u16() == 403 {
return netflix_item("No (IP Banned By Netflix)", None);
}
match response.json::<Value>().await {
Ok(data) => {
if let Some(targets) = data.get("targets").and_then(|t| t.as_array())
&& !targets.is_empty()
&& let Some(location) = targets[0].get("location")
&& let Some(country) = location.get("country").and_then(|c| c.as_str())
{
return UnlockItem::checked_region(NETFLIX, "Yes", country);
}
netflix_item("Unknown", None)
}
Err(e) => {
logging!(error, Type::Network, "解析Fast.com API响应失败: {e}");
netflix_item("Failed (解析错误)", None)
}
}
}
Err(e) => {
logging!(error, Type::Network, "Fast.com API请求失败: {e}");
netflix_item("Failed (CDN API)", None)
}
}
}
@@ -1,62 +0,0 @@
use regex::Regex;
use reqwest::Client;
use clash_verge_logging::{Type, logging};
use super::UnlockItem;
const PRIME_VIDEO: &str = "Prime Video";
fn prime_video_item(status: impl Into<String>, region: Option<String>) -> UnlockItem {
UnlockItem::checked(PRIME_VIDEO, status, region)
}
pub(super) async fn check_prime_video(client: &Client) -> UnlockItem {
let url = "https://www.primevideo.com";
let result = client.get(url).send().await;
let response = match result {
Ok(response) => response,
Err(_) => {
return prime_video_item("Failed (Network Connection)", None);
}
};
match response.text().await {
Ok(body) => {
let is_blocked = body.contains("isServiceRestricted");
let region_re = match Regex::new(r#""currentTerritory":"([^"]+)""#) {
Ok(re) => re,
Err(e) => {
logging!(
error,
Type::Network,
"Failed to compile Prime Video region regex: {}",
e
);
return prime_video_item("Failed (Regex Error)", None);
}
};
let region_code = region_re
.captures(&body)
.and_then(|caps| caps.get(1).map(|m| m.as_str().to_string()));
if is_blocked {
return prime_video_item("No (Service Not Available)", None);
}
if let Some(region) = region_code {
return UnlockItem::checked_region(PRIME_VIDEO, "Yes", &region);
}
if !is_blocked {
return prime_video_item("Failed (Error: PAGE ERROR)", None);
}
prime_video_item("Failed (Error: Unknown Region)", None)
}
Err(_) => prime_video_item("Failed (Error: Cannot read response)", None),
}
}
@@ -1,66 +0,0 @@
use reqwest::{Client, Url};
use super::UnlockItem;
pub(super) async fn check_spotify(client: &Client) -> UnlockItem {
let url = "https://www.spotify.com/api/content/v1/country-selector?platform=web&format=json";
match client.get(url).send().await {
Ok(response) => {
let final_url = response.url().clone();
let status_code = response.status();
let body = response.text().await.unwrap_or_default();
let region = extract_region(&final_url).or_else(|| extract_region_from_body(&body));
let status = determine_status(status_code.as_u16(), &body);
UnlockItem::checked("Spotify", status, region)
}
Err(_) => UnlockItem::checked("Spotify", "Failed", None),
}
}
fn determine_status(status: u16, body: &str) -> &'static str {
if status == 403 || status == 451 {
return "No";
}
if !(200..300).contains(&status) {
return "Failed";
}
let body_lower = body.to_lowercase();
if body_lower.contains("not available in your country") {
return "No";
}
"Yes"
}
fn extract_region(url: &Url) -> Option<String> {
let mut segments = url.path_segments()?;
let first_segment = segments.next()?;
if first_segment.is_empty() || first_segment == "api" {
return None;
}
let country_code = first_segment.split('-').next().unwrap_or(first_segment);
let upper = country_code.to_uppercase();
Some(UnlockItem::region_label(&upper))
}
fn extract_region_from_body(body: &str) -> Option<String> {
let marker = "\"countryCode\":\"";
if let Some(idx) = body.find(marker) {
let start = idx + marker.len();
let rest = &body[start..];
if let Some(end) = rest.find('"') {
let code = rest[..end].to_uppercase();
if !code.is_empty() {
return Some(UnlockItem::region_label(&code));
}
}
}
None
}
@@ -1,80 +0,0 @@
use std::sync::OnceLock;
use regex::Regex;
use reqwest::Client;
use super::UnlockItem;
pub(super) async fn check_tiktok(client: &Client) -> UnlockItem {
let trace_url = "https://www.tiktok.com/cdn-cgi/trace";
let mut status = String::from("Failed");
let mut region = None;
if let Ok(response) = client.get(trace_url).send().await {
let status_code = response.status().as_u16();
if let Ok(body) = response.text().await {
status = determine_status(status_code, &body).to_string();
region = extract_region_from_body(&body);
}
}
if (region.is_none() || status == "Failed")
&& let Ok(response) = client.get("https://www.tiktok.com/").send().await
{
let status_code = response.status().as_u16();
if let Ok(body) = response.text().await {
let fallback_status = determine_status(status_code, &body);
let fallback_region = extract_region_from_body(&body);
if status != "No" {
status = fallback_status.to_string();
}
if region.is_none() {
region = fallback_region;
}
}
}
UnlockItem::checked("TikTok", status, region)
}
fn determine_status(status: u16, body: &str) -> &'static str {
if status == 403 || status == 451 {
return "No";
}
if !(200..300).contains(&status) {
return "Failed";
}
let body_lower = body.to_lowercase();
if body_lower.contains("access denied")
|| body_lower.contains("not available in your region")
|| body_lower.contains("tiktok is not available")
{
return "No";
}
"Yes"
}
fn extract_region_from_body(body: &str) -> Option<String> {
static REGION_REGEX: OnceLock<Option<Regex>> = OnceLock::new();
let regex = REGION_REGEX
.get_or_init(|| Regex::new(r#""region"\s*:\s*"([a-zA-Z-]+)""#).ok())
.as_ref()?;
if let Some(caps) = regex.captures(body)
&& let Some(matched) = caps.get(1)
{
let raw = matched.as_str();
let country_code = raw.split('-').next().unwrap_or(raw).to_uppercase();
if !country_code.is_empty() {
return Some(UnlockItem::region_label(&country_code));
}
}
None
}
@@ -1,63 +0,0 @@
use serde::{Deserialize, Serialize};
use super::utils::{country_code_to_emoji, get_local_date_string};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UnlockItem {
pub name: String,
pub status: String,
pub region: Option<String>,
pub check_time: Option<String>,
}
impl UnlockItem {
pub fn checked(name: &str, status: impl Into<String>, region: Option<String>) -> Self {
Self {
name: name.to_string(),
status: status.into(),
region,
check_time: Some(get_local_date_string()),
}
}
pub fn checked_region(name: &str, status: impl Into<String>, country_code: &str) -> Self {
Self::checked(name, status, Some(Self::region_label(country_code)))
}
pub fn region_label(country_code: &str) -> String {
let emoji = country_code_to_emoji(country_code);
format!("{emoji}{country_code}")
}
pub fn pending(name: &str) -> Self {
Self {
name: name.to_string(),
status: "Pending".to_string(),
region: None,
check_time: None,
}
}
}
const DEFAULT_UNLOCK_ITEM_NAMES: [&str; 13] = [
"哔哩哔哩大陆",
"哔哩哔哩港澳台",
"ChatGPT iOS",
"ChatGPT Web",
"Claude",
"Gemini",
"YouTube Premium",
"Bahamut Anime",
"Netflix",
"Disney+",
"Prime Video",
"Spotify",
"TikTok",
];
pub fn default_unlock_items() -> Vec<UnlockItem> {
DEFAULT_UNLOCK_ITEM_NAMES
.iter()
.map(|name| UnlockItem::pending(name))
.collect()
}
@@ -1,76 +0,0 @@
use chrono::Local;
use rust_iso3166;
pub fn get_local_date_string() -> String {
let now = Local::now();
now.format("%Y-%m-%d %H:%M:%S").to_string()
}
pub fn country_code_to_emoji(country_code: &str) -> String {
let uc = country_code.to_ascii_uppercase();
// 长度校验:仅允许 2 或 3
match uc.len() {
2 => {
// 校验是否是合法 alpha2
if rust_iso3166::from_alpha2(&uc).is_none() {
return String::new();
}
alpha2_to_emoji(&uc)
}
3 => {
// 转换并校验 alpha3
match rust_iso3166::from_alpha3(&uc) {
Some(c) => {
let alpha2 = c.alpha2.to_ascii_uppercase();
alpha2_to_emoji(&alpha2)
}
None => String::new(),
}
}
_ => String::new(),
}
}
fn alpha2_to_emoji(alpha2: &str) -> String {
let bytes = alpha2.as_bytes();
let c1 = 0x1F1E6 + (bytes[0] as u32) - ('A' as u32);
let c2 = 0x1F1E6 + (bytes[1] as u32) - ('A' as u32);
char::from_u32(c1)
.and_then(|x| char::from_u32(c2).map(|y| format!("{x}{y}")))
.unwrap_or_default()
}
#[cfg(test)]
mod tests {
use super::country_code_to_emoji;
#[test]
fn country_code_to_emoji_iso2() {
assert_eq!(country_code_to_emoji("CN"), "🇨🇳");
assert_eq!(country_code_to_emoji("us"), "🇺🇸");
}
#[test]
fn country_code_to_emoji_iso3() {
assert_eq!(country_code_to_emoji("CHN"), "🇨🇳");
assert_eq!(country_code_to_emoji("USA"), "🇺🇸");
}
#[test]
fn country_code_to_emoji_invalid() {
assert_eq!(country_code_to_emoji("XXX"), "");
assert_eq!(country_code_to_emoji("ZZ"), "");
}
#[test]
fn country_code_to_emoji_short() {
assert_eq!(country_code_to_emoji("C"), "");
assert_eq!(country_code_to_emoji(""), "");
}
#[test]
fn country_code_to_emoji_long() {
assert_eq!(country_code_to_emoji("CNAAA"), "");
}
}
@@ -1,59 +0,0 @@
use regex::Regex;
use reqwest::Client;
use clash_verge_logging::{Type, logging};
use super::UnlockItem;
pub(super) async fn check_youtube_premium(client: &Client) -> UnlockItem {
let url = "https://www.youtube.com/premium?hl=en";
let item = |status: &str, region: Option<String>| UnlockItem::checked("YouTube Premium", status, region);
match client.get(url).send().await {
Ok(response) => {
let status_code = response.status().as_u16();
if let Ok(body) = response.text().await {
let body_lower = body.to_ascii_lowercase();
let region = [
r#"id=["']country-code["'][^>]*>\s*([A-Za-z]{2,3})\s*<"#,
r#""GL"\s*:\s*"([A-Za-z]{2})""#,
r#""countryCode"\s*:\s*"([A-Za-z]{2})""#,
r#""country_code"\s*:\s*"([A-Za-z]{2})""#,
]
.iter()
.find_map(|pattern| match Regex::new(pattern) {
Ok(re) => re
.captures(&body)
.and_then(|caps| caps.get(1))
.map(|m| m.as_str().trim().to_ascii_uppercase()),
Err(e) => {
logging!(error, Type::Network, "Failed to compile YouTube Premium regex: {}", e);
None
}
})
.map(|country_code| UnlockItem::region_label(&country_code));
let status = if body_lower.contains("youtube premium is not available in your country")
|| body_lower.contains("premium is not available in your country")
|| body_lower.contains("premium is not available in your region")
{
"No"
} else if (200..300).contains(&status_code)
&& (body_lower.contains("youtube premium")
|| body_lower.contains("ad-free")
|| body_lower.contains(r#""browseid":"spunlimited""#))
{
"Yes"
} else {
"Failed"
};
item(status, region)
} else {
item("Failed", None)
}
}
Err(_) => item("Failed", None),
}
}