Upload main.rs

src/main.rs

@@ -24,12 +24,12 @@ use cbc::Decryptor;
 use reqwest::{cookie::Jar, Url};
 use reqwest::cookie::CookieStore;
 use reqwest::header::ACCEPT;
-use lofty::{
-    config::WriteOptions,
-    picture::{Picture, PictureType},
-    tag::{Accessor, Tag, TagExt, TagType},
-};
-use std::io::Cursor;
+use lofty::{
+    config::WriteOptions,
+    picture::{Picture, PictureType},
+    tag::{Accessor, Tag, TagExt, TagType},
+};
+use std::io::Cursor;
 use std::time::{SystemTime, UNIX_EPOCH};
 use tokio::sync::{Mutex, RwLock};
 use tokio::time::{timeout, Duration};
@@ -53,8 +53,8 @@ struct CdnCacheEntry {
     expires_at: std::time::Instant,
 }
 
-#[derive(Clone)]
-struct AppState {
+#[derive(Clone)]
+struct AppState {
     api: Arc<Mutex<APIClient>>,
     api_by_arl: Arc<RwLock<HashMap<String, Arc<Mutex<APIClient>>>>>,
     arl_sessions: Arc<RwLock<HashMap<String, ArlSession>>>,
@@ -715,38 +715,38 @@ struct StreamParams {
     id: u64,
     format: Option<String>,
     arl: Option<String>,
-    title: Option<String>,
-    performer: Option<String>,
-    duration: Option<u64>,
-    album: Option<String>,
-    cover_url: Option<String>,
-}
-
-#[derive(Debug, Clone, Default)]
-struct AudioTagMeta {
-    title: Option<String>,
-    performer: Option<String>,
-    album: Option<String>,
-    cover_url: Option<String>,
-}
-
-fn normalized_opt(value: &Option<String>) -> Option<String> {
-    value
-        .as_ref()
-        .map(|s| s.trim().to_string())
-        .filter(|s| !s.is_empty())
-}
-
-impl From<&StreamParams> for AudioTagMeta {
-    fn from(params: &StreamParams) -> Self {
-        Self {
-            title: normalized_opt(&params.title),
-            performer: normalized_opt(&params.performer),
-            album: normalized_opt(&params.album),
-            cover_url: normalized_opt(&params.cover_url),
-        }
-    }
-}
+    title: Option<String>,
+    performer: Option<String>,
+    duration: Option<u64>,
+    album: Option<String>,
+    cover_url: Option<String>,
+}
+
+#[derive(Debug, Clone, Default)]
+struct AudioTagMeta {
+    title: Option<String>,
+    performer: Option<String>,
+    album: Option<String>,
+    cover_url: Option<String>,
+}
+
+fn normalized_opt(value: &Option<String>) -> Option<String> {
+    value
+        .as_ref()
+        .map(|s| s.trim().to_string())
+        .filter(|s| !s.is_empty())
+}
+
+impl From<&StreamParams> for AudioTagMeta {
+    fn from(params: &StreamParams) -> Self {
+        Self {
+            title: normalized_opt(&params.title),
+            performer: normalized_opt(&params.performer),
+            album: normalized_opt(&params.album),
+            cover_url: normalized_opt(&params.cover_url),
+        }
+    }
+}
 
 async fn stream_info(State(state): State<AppState>, Query(q): Query<StreamParams>) -> impl IntoResponse {
     let _ = std::fs::remove_file("debug_dzmedia.log");
@@ -869,97 +869,97 @@ struct SendAudioParams {
     title: Option<String>,
     performer: Option<String>,
     duration: Option<u64>,
-    album: Option<String>,
-    cover_url: Option<String>,
-}
-
-impl From<&SendAudioParams> for AudioTagMeta {
-    fn from(params: &SendAudioParams) -> Self {
-        Self {
-            title: normalized_opt(&params.title),
-            performer: normalized_opt(&params.performer),
-            album: normalized_opt(&params.album),
-            cover_url: normalized_opt(&params.cover_url),
-        }
-    }
-}
-
-async fn fetch_cover_picture(cover_url: &str) -> Option<Picture> {
-    let http = reqwest::Client::builder()
-        .timeout(Duration::from_secs(20))
-        .build()
-        .ok()?;
-    let resp = http.get(cover_url).send().await.ok()?;
-    if !resp.status().is_success() {
-        return None;
-    }
-    let bytes = resp.bytes().await.ok()?;
-    let mut picture = Picture::from_reader(&mut Cursor::new(bytes.to_vec())).ok()?;
-    picture.set_pic_type(PictureType::CoverFront);
-    Some(picture)
-}
-
-async fn inject_audio_metadata(mut bytes: Vec<u8>, ext: &str, meta: &AudioTagMeta) -> Vec<u8> {
-    let has_text = meta.title.is_some() || meta.performer.is_some() || meta.album.is_some();
-    let cover = match meta.cover_url.as_deref() {
-        Some(url) => fetch_cover_picture(url).await,
-        None => None,
-    };
-
-    if !has_text && cover.is_none() {
-        return bytes;
-    }
-
-    let tag_type = if ext.eq_ignore_ascii_case("flac") {
-        TagType::VorbisComments
-    } else {
-        TagType::Id3v2
-    };
-
-    let mut tag = Tag::new(tag_type);
-    if let Some(title) = meta.title.clone() {
-        tag.set_title(title);
-    }
-    if let Some(performer) = meta.performer.clone() {
-        tag.set_artist(performer);
-    }
-    if let Some(album) = meta.album.clone() {
-        tag.set_album(album);
-    }
-    if let Some(picture) = cover {
-        tag.push_picture(picture);
-    }
-
-    let unique = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|d| d.as_nanos())
-        .unwrap_or(0);
-    let temp_path = std::env::temp_dir().join(format!("dzmedia_tagged_{}.{}", unique, ext));
-    if let Err(e) = std::fs::write(&temp_path, &bytes) {
-        tracing::warn!("metadata temp write failed: {}", e);
-        return bytes;
-    }
-
-    let write_options = if ext.eq_ignore_ascii_case("mp3") {
-        WriteOptions::new().use_id3v23(true)
-    } else {
-        WriteOptions::new()
-    };
-
-    let write_result = tag.save_to_path(&temp_path, write_options);
-    if let Err(e) = write_result {
-        let _ = std::fs::remove_file(&temp_path);
-        tracing::warn!("metadata tagging failed: {}", e);
-        return bytes;
-    }
-
-    match std::fs::read(&temp_path) {
-        Ok(tagged) => bytes = tagged,
-        Err(e) => tracing::warn!("metadata temp read failed: {}", e),
-    }
-    let _ = std::fs::remove_file(&temp_path);
-    bytes
-}
+    album: Option<String>,
+    cover_url: Option<String>,
+}
+
+impl From<&SendAudioParams> for AudioTagMeta {
+    fn from(params: &SendAudioParams) -> Self {
+        Self {
+            title: normalized_opt(&params.title),
+            performer: normalized_opt(&params.performer),
+            album: normalized_opt(&params.album),
+            cover_url: normalized_opt(&params.cover_url),
+        }
+    }
+}
+
+async fn fetch_cover_picture(cover_url: &str) -> Option<Picture> {
+    let http = reqwest::Client::builder()
+        .timeout(Duration::from_secs(20))
+        .build()
+        .ok()?;
+    let resp = http.get(cover_url).send().await.ok()?;
+    if !resp.status().is_success() {
+        return None;
+    }
+    let bytes = resp.bytes().await.ok()?;
+    let mut picture = Picture::from_reader(&mut Cursor::new(bytes.to_vec())).ok()?;
+    picture.set_pic_type(PictureType::CoverFront);
+    Some(picture)
+}
+
+async fn inject_audio_metadata(mut bytes: Vec<u8>, ext: &str, meta: &AudioTagMeta) -> Vec<u8> {
+    let has_text = meta.title.is_some() || meta.performer.is_some() || meta.album.is_some();
+    let cover = match meta.cover_url.as_deref() {
+        Some(url) => fetch_cover_picture(url).await,
+        None => None,
+    };
+
+    if !has_text && cover.is_none() {
+        return bytes;
+    }
+
+    let tag_type = if ext.eq_ignore_ascii_case("flac") {
+        TagType::VorbisComments
+    } else {
+        TagType::Id3v2
+    };
+
+    let mut tag = Tag::new(tag_type);
+    if let Some(title) = meta.title.clone() {
+        tag.set_title(title);
+    }
+    if let Some(performer) = meta.performer.clone() {
+        tag.set_artist(performer);
+    }
+    if let Some(album) = meta.album.clone() {
+        tag.set_album(album);
+    }
+    if let Some(picture) = cover {
+        tag.push_picture(picture);
+    }
+
+    let unique = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_nanos())
+        .unwrap_or(0);
+    let temp_path = std::env::temp_dir().join(format!("dzmedia_tagged_{}.{}", unique, ext));
+    if let Err(e) = std::fs::write(&temp_path, &bytes) {
+        tracing::warn!("metadata temp write failed: {}", e);
+        return bytes;
+    }
+
+    let write_options = if ext.eq_ignore_ascii_case("mp3") {
+        WriteOptions::new().use_id3v23(true)
+    } else {
+        WriteOptions::new()
+    };
+
+    let write_result = tag.save_to_path(&temp_path, write_options);
+    if let Err(e) = write_result {
+        let _ = std::fs::remove_file(&temp_path);
+        tracing::warn!("metadata tagging failed: {}", e);
+        return bytes;
+    }
+
+    match std::fs::read(&temp_path) {
+        Ok(tagged) => bytes = tagged,
+        Err(e) => tracing::warn!("metadata temp read failed: {}", e),
+    }
+    let _ = std::fs::remove_file(&temp_path);
+    bytes
+}
 
 async fn send_audio(
     State(state): State<AppState>,
@@ -1066,81 +1066,81 @@ async fn send_audio(
         bi += 1; pos += bs;
     }
 
-    let ext = if used_fmt.contains("FLAC") || content_type.contains("flac") { "flac" } else { "mp3" };
-    let meta = AudioTagMeta::from(&q);
-    dec = inject_audio_metadata(dec, ext, &meta).await;
+    let ext = if used_fmt.contains("FLAC") || content_type.contains("flac") { "flac" } else { "mp3" };
+    let meta = AudioTagMeta::from(&q);
+    dec = inject_audio_metadata(dec, ext, &meta).await;
     let mime = if ext == "flac" { "audio/flac" } else { "audio/mpeg" };
     let filename = format!("track_{}.{}", q.id, ext);
 
-    // Загружаем в Telegram через отдельный клиент.
-    // Если аплоад виснет по сети, важно быстро вернуть ошибку боту,
-    // чтобы он раньше переключился на fallback по URL.
+    // Загружаем в Telegram через отдельный клиент.
+    // Если аплоад виснет по сети, важно быстро вернуть ошибку боту,
+    // чтобы он раньше переключился на fallback по URL.
     let tg_url = format!("https://api.telegram.org/bot{}/sendAudio", bot_token);
-    let tg_http = reqwest::Client::builder()
-        .https_only(true)
-        .connect_timeout(Duration::from_secs(8))
-        .timeout(Duration::from_secs(18))
-        .tcp_keepalive(Duration::from_secs(30))
-        .build()
-        .unwrap();
-
-    let mut tg_json: Option<serde_json::Value> = None;
-    let mut last_tg_err: Option<String> = None;
-
-    for attempt in 1..=2u8 {
-        let part = reqwest::multipart::Part::bytes(dec.clone())
-            .file_name(filename.clone())
-            .mime_str(mime)
-            .unwrap();
-        let mut form = reqwest::multipart::Form::new()
-            .text("chat_id", q.chat_id.clone())
-            .part("audio", part);
-        if let Some(ref t) = q.title { form = form.text("title", t.clone()); }
-        if let Some(ref p) = q.performer { form = form.text("performer", p.clone()); }
-        if let Some(d) = q.duration { form = form.text("duration", d.to_string()); }
-
-        match tg_http.post(&tg_url).multipart(form).send().await {
-            Ok(resp) => {
-                let status = resp.status();
-                match resp.json::<serde_json::Value>().await {
-                    Ok(j) => {
-                        if status.is_success() && j.get("ok").and_then(|v| v.as_bool()) == Some(true) {
-                            tg_json = Some(j);
-                            break;
-                        }
-                        let desc = j
-                            .get("description")
-                            .and_then(|v| v.as_str())
-                            .unwrap_or("unknown")
-                            .to_string();
-                        tracing::warn!("Telegram sendAudio attempt {} failed: status={} desc={}", attempt, status, desc);
-                        last_tg_err = Some(format!("Telegram {}: {}", status, desc));
-                    }
-                    Err(e) => {
-                        tracing::warn!("Telegram sendAudio attempt {} parse failed: {}", attempt, e);
-                        last_tg_err = Some(format!("Telegram parse: {}", e));
-                    }
-                }
-            }
-            Err(e) => {
-                tracing::warn!("Telegram sendAudio attempt {} upload failed: {}", attempt, e);
-                last_tg_err = Some(format!("Telegram upload: {}", e));
-            }
-        }
-
-        if attempt < 2 {
-            tokio::time::sleep(Duration::from_secs(1)).await;
-        }
-    }
-
-    let tg_json = match tg_json {
-        Some(j) => j,
-        None => {
-            let err = last_tg_err.unwrap_or_else(|| "Telegram upload failed".to_string());
-            tracing::error!("Telegram sendAudio final failure: {}", err);
-            return json_error(StatusCode::BAD_GATEWAY, err);
-        }
-    };
+    let tg_http = reqwest::Client::builder()
+        .https_only(true)
+        .connect_timeout(Duration::from_secs(8))
+        .timeout(Duration::from_secs(18))
+        .tcp_keepalive(Duration::from_secs(30))
+        .build()
+        .unwrap();
+
+    let mut tg_json: Option<serde_json::Value> = None;
+    let mut last_tg_err: Option<String> = None;
+
+    for attempt in 1..=2u8 {
+        let part = reqwest::multipart::Part::bytes(dec.clone())
+            .file_name(filename.clone())
+            .mime_str(mime)
+            .unwrap();
+        let mut form = reqwest::multipart::Form::new()
+            .text("chat_id", q.chat_id.clone())
+            .part("audio", part);
+        if let Some(ref t) = q.title { form = form.text("title", t.clone()); }
+        if let Some(ref p) = q.performer { form = form.text("performer", p.clone()); }
+        if let Some(d) = q.duration { form = form.text("duration", d.to_string()); }
+
+        match tg_http.post(&tg_url).multipart(form).send().await {
+            Ok(resp) => {
+                let status = resp.status();
+                match resp.json::<serde_json::Value>().await {
+                    Ok(j) => {
+                        if status.is_success() && j.get("ok").and_then(|v| v.as_bool()) == Some(true) {
+                            tg_json = Some(j);
+                            break;
+                        }
+                        let desc = j
+                            .get("description")
+                            .and_then(|v| v.as_str())
+                            .unwrap_or("unknown")
+                            .to_string();
+                        tracing::warn!("Telegram sendAudio attempt {} failed: status={} desc={}", attempt, status, desc);
+                        last_tg_err = Some(format!("Telegram {}: {}", status, desc));
+                    }
+                    Err(e) => {
+                        tracing::warn!("Telegram sendAudio attempt {} parse failed: {}", attempt, e);
+                        last_tg_err = Some(format!("Telegram parse: {}", e));
+                    }
+                }
+            }
+            Err(e) => {
+                tracing::warn!("Telegram sendAudio attempt {} upload failed: {}", attempt, e);
+                last_tg_err = Some(format!("Telegram upload: {}", e));
+            }
+        }
+
+        if attempt < 2 {
+            tokio::time::sleep(Duration::from_secs(1)).await;
+        }
+    }
+
+    let tg_json = match tg_json {
+        Some(j) => j,
+        None => {
+            let err = last_tg_err.unwrap_or_else(|| "Telegram upload failed".to_string());
+            tracing::error!("Telegram sendAudio final failure: {}", err);
+            return json_error(StatusCode::BAD_GATEWAY, err);
+        }
+    };
 
     let file_id = tg_json.pointer("/result/audio/file_id")
         .and_then(|v| v.as_str())
@@ -1281,10 +1281,31 @@ async fn download(
     }
 
     // Determine file extension
-    let ext = if used_fmt.contains("FLAC") || content_type.contains("flac") { "flac" } else { "mp3" };
-    let meta = AudioTagMeta::from(&q);
-    dec = inject_audio_metadata(dec, ext, &meta).await;
-    let filename = format!("track_{}.{}", q.id, ext);
+    let ext = if used_fmt.contains("FLAC") || content_type.contains("flac") { "flac" } else { "mp3" };
+    let meta = AudioTagMeta::from(&q);
+    dec = inject_audio_metadata(dec, ext, &meta).await;
+    
+    // Generate filename from metadata
+    let filename = if let Some(ref title) = meta.title {
+        let safe_title = title
+            .replace(['/', '\\', ':', '*', '?', '"', '<', '>', '|'], "_")
+            .chars()
+            .take(100)
+            .collect::<String>();
+        if let Some(ref performer) = meta.performer {
+            let safe_performer = performer
+                .replace(['/', '\\', ':', '*', '?', '"', '<', '>', '|'], "_")
+                .chars()
+                .take(50)
+                .collect::<String>();
+            format!("{} - {}.{}", safe_performer, safe_title, ext)
+        } else {
+            format!("{}.{}", safe_title, ext)
+        }
+    } else {
+        format!("track_{}.{}", q.id, ext)
+    };
+    
     let ct = if ext == "flac" { "audio/flac" } else { "audio/mpeg" };
 
     axum::response::Response::builder()