Upload 2 files

src/main.rs

@@ -143,14 +143,31 @@ fn extract_media_url(media_json: &serde_json::Value) -> String {
     };
     for m in media_arr {
         if let Some(sources) = m.get("sources").and_then(|v| v.as_array()) {
+            let mut preferred = Vec::new();
+            if let Some(s1) = sources.get(1).and_then(|s| s.get("url")).and_then(|u| u.as_str()) {
+                preferred.push(s1);
+            }
             for s in sources {
-                if let Some(url) = s.get("url").and_then(|v| v.as_str()) {
-                    let url = url.trim();
-                    if !url.is_empty() {
-                        return url.to_string();
+                if let Some(u) = s.get("url").and_then(|v| v.as_str()) {
+                    if u.contains("dzcdn.net/media/") {
+                        preferred.push(u);
                     }
                 }
             }
+            if let Some(s0) = sources.get(0).and_then(|s| s.get("url")).and_then(|u| u.as_str()) {
+                preferred.push(s0);
+            }
+            for s in sources {
+                if let Some(u) = s.get("url").and_then(|v| v.as_str()) {
+                    preferred.push(u);
+                }
+            }
+            for p in preferred {
+                let p = p.trim();
+                if !p.is_empty() {
+                    return p.to_string();
+                }
+            }
         }
     }
     String::new()
@@ -2237,6 +2254,86 @@ async fn api_deezer_get(
     Ok(v)
 }
 
+async fn api_deezer_post(
+    client: &reqwest::Client,
+    path: &str,
+    access_token: &str,
+    form: &[(&str, String)],
+) -> Result<serde_json::Value, String> {
+    let url = format!("https://api.deezer.com{path}");
+    let mut req = client
+        .post(url)
+        .header("Authorization", format!("Bearer {}", access_token))
+        .query(&[("access_token", access_token)]);
+    if !form.is_empty() {
+        req = req.form(form);
+    }
+    let r = req.send().await.map_err(|_| "api:network".to_string())?;
+    let status = r.status();
+    let text = r.text().await.map_err(|_| "api:read".to_string())?;
+    
+    if text.trim() == "true" {
+        return Ok(json!(true));
+    }
+    if text.trim() == "false" {
+        return Ok(json!(false));
+    }
+    
+    let v: serde_json::Value = serde_json::from_str(&text).map_err(|_| {
+        let snip: String = text.chars().take(200).collect();
+        format!("api:parse:{}:{}", status.as_u16(), snip)
+    })?;
+    if let Some(e) = v.get("error") {
+        if e.is_object() {
+            let code = e.get("code").and_then(|x| x.as_i64()).unwrap_or(0);
+            let msg = e.get("message").and_then(|x| x.as_str()).unwrap_or("error");
+            return Err(format!("api:{code}:{msg}"));
+        }
+        return Err("api:error".to_string());
+    }
+    Ok(v)
+}
+
+async fn api_deezer_delete(
+    client: &reqwest::Client,
+    path: &str,
+    access_token: &str,
+    query: &[(&str, String)],
+) -> Result<serde_json::Value, String> {
+    let url = format!("https://api.deezer.com{path}");
+    let mut req = client
+        .delete(url)
+        .header("Authorization", format!("Bearer {}", access_token))
+        .query(&[("access_token", access_token)]);
+    if !query.is_empty() {
+        req = req.query(query);
+    }
+    let r = req.send().await.map_err(|_| "api:network".to_string())?;
+    let status = r.status();
+    let text = r.text().await.map_err(|_| "api:read".to_string())?;
+    
+    if text.trim() == "true" {
+        return Ok(json!(true));
+    }
+    if text.trim() == "false" {
+        return Ok(json!(false));
+    }
+    
+    let v: serde_json::Value = serde_json::from_str(&text).map_err(|_| {
+        let snip: String = text.chars().take(200).collect();
+        format!("api:parse:{}:{}", status.as_u16(), snip)
+    })?;
+    if let Some(e) = v.get("error") {
+        if e.is_object() {
+            let code = e.get("code").and_then(|x| x.as_i64()).unwrap_or(0);
+            let msg = e.get("message").and_then(|x| x.as_str()).unwrap_or("error");
+            return Err(format!("api:{code}:{msg}"));
+        }
+        return Err("api:error".to_string());
+    }
+    Ok(v)
+}
+
 async fn pair_complete(State(state): State<AppState>, Form(f): Form<PairCompleteForm>) -> impl IntoResponse {
     let code     = f.code.trim().to_string();
     let email    = f.email.trim().to_string();
@@ -2723,6 +2820,118 @@ async fn oauth_flow(Json(req): Json<OauthFlowReq>) -> impl IntoResponse {
     }
 }
 
+#[derive(Debug, Deserialize)]
+struct OauthActionReq {
+    access_token: String,
+    track_id: Option<String>,
+    playlist_id: Option<String>,
+    title: Option<String>,
+}
+
+async fn oauth_favorite_add(Json(req): Json<OauthActionReq>) -> impl IntoResponse {
+    let token = req.access_token.trim().to_string();
+    let track_id = req.track_id.unwrap_or_default().trim().to_string();
+    if token.is_empty() || track_id.is_empty() {
+        return json_error(StatusCode::BAD_REQUEST, "access_token and track_id required");
+    }
+    let client = reqwest::Client::builder().no_proxy().timeout(std::time::Duration::from_secs(15)).build().unwrap();
+    let me = match api_deezer_get(&client, "/user/me", &token, &[]).await {
+        Ok(v) => v,
+        Err(e) => return json_error(StatusCode::SERVICE_UNAVAILABLE, e),
+    };
+    let uid = me.get("id").and_then(|x| x.as_i64()).unwrap_or(0);
+    
+    let path = format!("/user/{uid}/tracks");
+    match api_deezer_post(&client, &path, &token, &[("track_id", track_id)]).await {
+        Ok(v) => (StatusCode::OK, Json(v)).into_response(),
+        Err(e) => json_error(StatusCode::SERVICE_UNAVAILABLE, e),
+    }
+}
+
+async fn oauth_favorite_remove(Json(req): Json<OauthActionReq>) -> impl IntoResponse {
+    let token = req.access_token.trim().to_string();
+    let track_id = req.track_id.unwrap_or_default().trim().to_string();
+    if token.is_empty() || track_id.is_empty() {
+        return json_error(StatusCode::BAD_REQUEST, "access_token and track_id required");
+    }
+    let client = reqwest::Client::builder().no_proxy().timeout(std::time::Duration::from_secs(15)).build().unwrap();
+    let me = match api_deezer_get(&client, "/user/me", &token, &[]).await {
+        Ok(v) => v,
+        Err(e) => return json_error(StatusCode::SERVICE_UNAVAILABLE, e),
+    };
+    let uid = me.get("id").and_then(|x| x.as_i64()).unwrap_or(0);
+    
+    let path = format!("/user/{uid}/tracks");
+    match api_deezer_delete(&client, &path, &token, &[("track_id", track_id)]).await {
+        Ok(v) => (StatusCode::OK, Json(v)).into_response(),
+        Err(e) => json_error(StatusCode::SERVICE_UNAVAILABLE, e),
+    }
+}
+
+async fn oauth_playlist_add(Json(req): Json<OauthActionReq>) -> impl IntoResponse {
+    let token = req.access_token.trim().to_string();
+    let track_id = req.track_id.unwrap_or_default().trim().to_string();
+    let playlist_id = req.playlist_id.unwrap_or_default().trim().to_string();
+    if token.is_empty() || track_id.is_empty() || playlist_id.is_empty() {
+        return json_error(StatusCode::BAD_REQUEST, "access_token, track_id, playlist_id required");
+    }
+    let client = reqwest::Client::builder().no_proxy().timeout(std::time::Duration::from_secs(15)).build().unwrap();
+    let path = format!("/playlist/{playlist_id}/tracks");
+    match api_deezer_post(&client, &path, &token, &[("songs", track_id)]).await {
+        Ok(v) => (StatusCode::OK, Json(v)).into_response(),
+        Err(e) => json_error(StatusCode::SERVICE_UNAVAILABLE, e),
+    }
+}
+
+async fn oauth_playlist_create(Json(req): Json<OauthActionReq>) -> impl IntoResponse {
+    let token = req.access_token.trim().to_string();
+    let title = req.title.unwrap_or_default().trim().to_string();
+    if token.is_empty() || title.is_empty() {
+        return json_error(StatusCode::BAD_REQUEST, "access_token and title required");
+    }
+    let client = reqwest::Client::builder().no_proxy().timeout(std::time::Duration::from_secs(15)).build().unwrap();
+    let me = match api_deezer_get(&client, "/user/me", &token, &[]).await {
+        Ok(v) => v,
+        Err(e) => return json_error(StatusCode::SERVICE_UNAVAILABLE, e),
+    };
+    let uid = me.get("id").and_then(|x| x.as_i64()).unwrap_or(0);
+    
+    let path = format!("/user/{uid}/playlists");
+    match api_deezer_post(&client, &path, &token, &[("title", title)]).await {
+        Ok(v) => (StatusCode::OK, Json(v)).into_response(),
+        Err(e) => json_error(StatusCode::SERVICE_UNAVAILABLE, e),
+    }
+}
+
+async fn oauth_playlist_update(Json(req): Json<OauthActionReq>) -> impl IntoResponse {
+    let token = req.access_token.trim().to_string();
+    let title = req.title.unwrap_or_default().trim().to_string();
+    let playlist_id = req.playlist_id.unwrap_or_default().trim().to_string();
+    if token.is_empty() || title.is_empty() || playlist_id.is_empty() {
+        return json_error(StatusCode::BAD_REQUEST, "access_token, title, playlist_id required");
+    }
+    let client = reqwest::Client::builder().no_proxy().timeout(std::time::Duration::from_secs(15)).build().unwrap();
+    let path = format!("/playlist/{playlist_id}");
+    match api_deezer_post(&client, &path, &token, &[("title", title)]).await {
+        Ok(v) => (StatusCode::OK, Json(v)).into_response(),
+        Err(e) => json_error(StatusCode::SERVICE_UNAVAILABLE, e),
+    }
+}
+
+async fn oauth_playlist_delete(Json(req): Json<OauthActionReq>) -> impl IntoResponse {
+    let token = req.access_token.trim().to_string();
+    let playlist_id = req.playlist_id.unwrap_or_default().trim().to_string();
+    if token.is_empty() || playlist_id.is_empty() {
+        return json_error(StatusCode::BAD_REQUEST, "access_token and playlist_id required");
+    }
+    let client = reqwest::Client::builder().no_proxy().timeout(std::time::Duration::from_secs(15)).build().unwrap();
+    let path = format!("/playlist/{playlist_id}");
+    match api_deezer_delete(&client, &path, &token, &[]).await {
+        Ok(v) => (StatusCode::OK, Json(v)).into_response(),
+        Err(e) => json_error(StatusCode::SERVICE_UNAVAILABLE, e),
+    }
+}
+
 #[derive(Debug, Deserialize)]
 struct OauthRecoReq {
     access_token: String,
@@ -2964,6 +3173,12 @@ async fn main() {
         .route("/oauth/reco_artists", post(oauth_reco_artists))
         .route("/oauth/reco_tracks", post(oauth_reco_tracks))
         .route("/oauth/history", post(oauth_history))
+        .route("/oauth/favorite_add", post(oauth_favorite_add))
+        .route("/oauth/favorite_remove", post(oauth_favorite_remove))
+        .route("/oauth/playlist_add", post(oauth_playlist_add))
+        .route("/oauth/playlist_create", post(oauth_playlist_create))
+        .route("/oauth/playlist_update", post(oauth_playlist_update))
+        .route("/oauth/playlist_delete", post(oauth_playlist_delete))
         .with_state(state)
         .layer(cors)
         .layer(CompressionLayer::new())