Upload main.rs

src/main.rs

@@ -297,6 +297,27 @@ async fn fetch_media_url(
     ))
 }
 
+async fn resolve_fallback_id(client: &mut APIClient, id: u64) -> u64 {
+    if client.license_token.is_empty() {
+        let _ = client.force_renew().await;
+    }
+    let q_json = serde_json::json!({"sng_ids":[id],"array_default":["SNG_ID","FALLBACK"]});
+    if let Ok(r) = client.api_call::<serde_json::Value, serde_json::Value>("song.getListData", &q_json).await {
+        if let Some(item) = r.pointer("/data/0") {
+            if let Some(fallback) = item.get("FALLBACK") {
+                if let Some(fid) = fallback.get("SNG_ID").and_then(|v| {
+                    if let Some(s) = v.as_str() { s.parse::<u64>().ok() }
+                    else if let Some(n) = v.as_u64() { Some(n) }
+                    else { None }
+                }) {
+                    if fid > 0 { return fid; }
+                }
+            }
+        }
+    }
+    id
+}
+
 async fn media_url_for_track(
     client: &mut APIClient,
     id: u64,
@@ -399,9 +420,26 @@ async fn media_url_for_track(
 }
 
 fn upstream_bases() -> Vec<String> {
-    Vec::new()
-}
+    let mut out: Vec<String> = Vec::new();
+
+    let env = std::env::var("DZMEDIA_UPSTREAM").ok().unwrap_or_default();
+    let env = env.trim();
+    if env == "-" {
+        return out;
+    }
+
+    if !env.is_empty() {
+        for part in env.split(',') {
+            let s = part.trim();
+            if s.is_empty() {
+                continue;
+            }
+            out.push(s.trim_end_matches('/').to_string());
+        }
+    }
 
+    out
+}
 fn upstream_get_url_endpoint(base: &str) -> String {
     let b = base.trim_end_matches('/');
     if b.ends_with("/get_url") {
@@ -410,6 +448,7 @@ fn upstream_get_url_endpoint(base: &str) -> String {
         format!("{b}/get_url")
     }
 }
+}
 
 async fn upstream_get_url_text(formats: &Vec<Format>, ids: &Vec<u64>) -> Result<String, String> {
     let bases = upstream_bases();
@@ -678,8 +717,14 @@ async fn stream_info(State(state): State<AppState>, Query(q): Query<StreamParams
     let mut used: String = String::new();
     let mut last_err: Option<String> = None;
 
+    let client = api_client_for_arl(&state, q.arl.clone()).await;
+    let target_id = {
+        let mut c = client.lock().await;
+        resolve_fallback_id(&mut c, q.id).await
+    };
+
     // Upstream (опционально — если DZMEDIA_UPSTREAM задан)
-    if let Ok(text) = upstream_get_url_text(&formats, &vec![q.id]).await {
+    if let Ok(text) = upstream_get_url_text(&formats, &vec![target_id]).await {
         if let Ok(v) = serde_json::from_str::<serde_json::Value>(&text) {
             let format_strings: Vec<String> = formats.iter().map(|f| format!("{:?}", f)).collect();
             let format_strs: Vec<&str> = format_strings.iter().map(|s| s.as_str()).collect();
@@ -782,7 +827,6 @@ async fn stream(
         .filter(|s| !s.is_empty());
 
     let mut url: Option<String> = None;
-    let mut decrypt_id = q.id;
     let mut last_err: Option<String> = None;
 
     if arl_key.is_none() {
@@ -790,6 +834,13 @@ async fn stream(
         return (StatusCode::SERVICE_UNAVAILABLE, "arl required").into_response();
     }
 
+    let client = api_client_for_arl(&state, arl_key.clone()).await;
+    let target_id = {
+        let mut c = client.lock().await;
+        resolve_fallback_id(&mut c, q.id).await
+    };
+    let mut decrypt_id = target_id;
+
     for attempt in 0..2u8 {
         if url.is_some() { break; }
 
@@ -810,7 +861,7 @@ async fn stream(
                     continue;
                 }
             }
-            match timeout(Duration::from_secs(12), media_url_for_track(&mut c, q.id, &formats)).await {
+            match timeout(Duration::from_secs(12), media_url_for_track(&mut c, target_id, &formats)).await {
                 Ok(v) => v,
                 Err(_) => Err("timeout".to_string()),
             }