mirror of
https://github.com/clash-verge-rev/clash-verge-rev.git
synced 2026-11-18 09:52:13 +08:00
refactor: extract media unlock checker crate
This commit is contained in:
@@ -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(®ion))),
|
||||
))
|
||||
}
|
||||
|
||||
#[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", ®ion);
|
||||
}
|
||||
|
||||
if is_unavailable {
|
||||
return disney_item("No", None);
|
||||
}
|
||||
|
||||
match in_supported_location {
|
||||
Some(false) => disney_item(
|
||||
"Soon",
|
||||
Some(format!("{}(即将上线)", UnlockItem::region_label(®ion))),
|
||||
),
|
||||
Some(true) => UnlockItem::checked_region(DISNEY_PLUS, "Yes", ®ion),
|
||||
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(),
|
||||
}
|
||||
}
|
||||
@@ -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", ®ion);
|
||||
}
|
||||
|
||||
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),
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user