Upload main.rs

src/main.rs

@@ -1008,6 +1008,8 @@ async fn gw_light_call(
                 ("cid", cid.as_str()),
             ])
             .header(ACCEPT, "*/*")
+            .header("Cache-Control", "max-age=0")
+            .header("Connection", "keep-alive")
             .header("Origin", "https://www.deezer.com")
             .header("Referer", "https://www.deezer.com/")
             .header("Sec-Fetch-Site", "same-origin")
@@ -1015,6 +1017,9 @@ async fn gw_light_call(
             .header("Sec-Fetch-Dest", "empty")
             .header("X-Requested-With", "XMLHttpRequest")
             .header("Accept-Language", "en-US,en;q=0.9")
+            .header("Content-Language", "en-US")
+            .header("X-User-IP", "1.1.1.1")
+            .header("x-deezer-client-ip", "1.1.1.1")
             .header(
                 "User-Agent",
                 "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36",
@@ -1388,12 +1393,10 @@ async fn pair_complete(State(state): State<AppState>, Form(f): Form<PairComplete
         Err(e) => oauth_err = Some(e),
     }
 
-    match gw_light_call(&client, &jar, "deezer.getUserData", "null", json!({})).await {
-        Ok(ud) => {
-            let token = ud["checkForm"].as_str().unwrap_or("").to_string();
-            if token.is_empty() {
-                gw_err = Some("gw:no_checkForm".to_string());
-            } else if let Err(e) = gw_light_call(
+    if let Ok(ud) = gw_light_call(&client, &jar, "deezer.getUserData", "null", json!({})).await {
+        let token = ud["checkForm"].as_str().unwrap_or("").to_string();
+        if !token.is_empty() {
+            if let Err(e) = gw_light_call(
                 &client,
                 &jar,
                 "user.checkCredentials",
@@ -1406,15 +1409,18 @@ async fn pair_complete(State(state): State<AppState>, Form(f): Form<PairComplete
             )
             .await
             {
-                gw_err = Some(format!("gw:checkCredentials:{e}"));
                 if access_token_out.is_none() {
-                    let msg = gw_err.clone().unwrap_or_else(|| "gw:checkCredentials".to_string());
                     let mut map = state.pair.write().await;
                     if let Some(s) = map.get_mut(&code) {
-                        s.error = Some(msg.clone());
+                        s.error = Some(format!("gw:checkCredentials:{e}"));
                     }
-                    return Html(format!("<h3>Ошибка входа</h3><pre>{}</pre>", htmlesc(&msg))).into_response();
+                    return Html(format!(
+                        "<h3>Ошибка входа</h3><pre>{}</pre>",
+                        htmlesc(&format!("gw:checkCredentials:{e}"))
+                    ))
+                    .into_response();
                 }
+                gw_err = Some(format!("gw:checkCredentials:{e}"));
             } else {
                 gw_token = Some(token.clone());
                 gw_uid = ud["USER"]["USER_ID"]
@@ -1431,9 +1437,6 @@ async fn pair_complete(State(state): State<AppState>, Form(f): Form<PairComplete
                 }
             }
         }
-        Err(e) => {
-            gw_err = Some(format!("gw:getUserData:{e}"));
-        }
     }
 
     if gw_token.is_none() && access_token_out.is_none() {
@@ -1699,160 +1702,6 @@ async fn oauth_flow(Json(req): Json<OauthFlowReq>) -> impl IntoResponse {
     }
 }
 
-#[derive(Debug, Deserialize)]
-struct OauthRecoReq {
-    access_token: String,
-    index: Option<u32>,
-    limit: Option<u32>,
-}
-
-async fn oauth_reco_playlists(Json(req): Json<OauthRecoReq>) -> impl IntoResponse {
-    let token = req.access_token.trim().to_string();
-    if token.is_empty() {
-        return json_error(StatusCode::BAD_REQUEST, "access_token required");
-    }
-    let index = req.index.unwrap_or(0).to_string();
-    let limit = req.limit.unwrap_or(20).clamp(1, 50).to_string();
-    let client = reqwest::Client::builder()
-        .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);
-    if uid <= 0 {
-        return json_error(StatusCode::SERVICE_UNAVAILABLE, "api:no_user_id");
-    }
-    let path = format!("/user/{uid}/recommendations/playlists");
-    let extra = [("index", index), ("limit", limit)];
-    match api_deezer_get(&client, &path, &token, &extra).await {
-        Ok(v) => (StatusCode::OK, Json(v)).into_response(),
-        Err(e) => json_error(StatusCode::SERVICE_UNAVAILABLE, e),
-    }
-}
-
-async fn oauth_reco_albums(Json(req): Json<OauthRecoReq>) -> impl IntoResponse {
-    let token = req.access_token.trim().to_string();
-    if token.is_empty() {
-        return json_error(StatusCode::BAD_REQUEST, "access_token required");
-    }
-    let index = req.index.unwrap_or(0).to_string();
-    let limit = req.limit.unwrap_or(20).clamp(1, 50).to_string();
-    let client = reqwest::Client::builder()
-        .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);
-    if uid <= 0 {
-        return json_error(StatusCode::SERVICE_UNAVAILABLE, "api:no_user_id");
-    }
-    let path = format!("/user/{uid}/recommendations/albums");
-    let extra = [("index", index), ("limit", limit)];
-    match api_deezer_get(&client, &path, &token, &extra).await {
-        Ok(v) => (StatusCode::OK, Json(v)).into_response(),
-        Err(e) => json_error(StatusCode::SERVICE_UNAVAILABLE, e),
-    }
-}
-
-async fn oauth_reco_artists(Json(req): Json<OauthRecoReq>) -> impl IntoResponse {
-    let token = req.access_token.trim().to_string();
-    if token.is_empty() {
-        return json_error(StatusCode::BAD_REQUEST, "access_token required");
-    }
-    let index = req.index.unwrap_or(0).to_string();
-    let limit = req.limit.unwrap_or(20).clamp(1, 50).to_string();
-    let client = reqwest::Client::builder()
-        .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);
-    if uid <= 0 {
-        return json_error(StatusCode::SERVICE_UNAVAILABLE, "api:no_user_id");
-    }
-    let path = format!("/user/{uid}/recommendations/artists");
-    let extra = [("index", index), ("limit", limit)];
-    match api_deezer_get(&client, &path, &token, &extra).await {
-        Ok(v) => (StatusCode::OK, Json(v)).into_response(),
-        Err(e) => json_error(StatusCode::SERVICE_UNAVAILABLE, e),
-    }
-}
-
-async fn oauth_reco_tracks(Json(req): Json<OauthRecoReq>) -> impl IntoResponse {
-    let token = req.access_token.trim().to_string();
-    if token.is_empty() {
-        return json_error(StatusCode::BAD_REQUEST, "access_token required");
-    }
-    let index = req.index.unwrap_or(0).to_string();
-    let limit = req.limit.unwrap_or(40).clamp(1, 100).to_string();
-    let client = reqwest::Client::builder()
-        .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);
-    if uid <= 0 {
-        return json_error(StatusCode::SERVICE_UNAVAILABLE, "api:no_user_id");
-    }
-    let path = format!("/user/{uid}/recommendations/tracks");
-    let extra = [("index", index), ("limit", limit)];
-    match api_deezer_get(&client, &path, &token, &extra).await {
-        Ok(v) => (StatusCode::OK, Json(v)).into_response(),
-        Err(e) => json_error(StatusCode::SERVICE_UNAVAILABLE, e),
-    }
-}
-
-#[derive(Debug, Deserialize)]
-struct OauthHistoryReq {
-    access_token: String,
-    index: Option<u32>,
-    limit: Option<u32>,
-}
-
-async fn oauth_history(Json(req): Json<OauthHistoryReq>) -> impl IntoResponse {
-    let token = req.access_token.trim().to_string();
-    if token.is_empty() {
-        return json_error(StatusCode::BAD_REQUEST, "access_token required");
-    }
-    let index = req.index.unwrap_or(0).to_string();
-    let limit = req.limit.unwrap_or(50).clamp(1, 100).to_string();
-    let client = reqwest::Client::builder()
-        .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);
-    if uid <= 0 {
-        return json_error(StatusCode::SERVICE_UNAVAILABLE, "api:no_user_id");
-    }
-    let path = format!("/user/{uid}/history");
-    let extra = [("index", index), ("limit", limit)];
-    match api_deezer_get(&client, &path, &token, &extra).await {
-        Ok(v) => (StatusCode::OK, Json(v)).into_response(),
-        Err(e) => json_error(StatusCode::SERVICE_UNAVAILABLE, e),
-    }
-}
-
 #[tokio::main]
 async fn main() {
     let bind_addr = std::env::var("BIND_ADDR").unwrap_or("[::]".to_string());
@@ -1891,11 +1740,6 @@ async fn main() {
         .route("/oauth/playlist_tracks", post(oauth_playlist_tracks))
         .route("/oauth/arl", post(oauth_arl))
         .route("/oauth/flow", post(oauth_flow))
-        .route("/oauth/reco_playlists", post(oauth_reco_playlists))
-        .route("/oauth/reco_albums", post(oauth_reco_albums))
-        .route("/oauth/reco_artists", post(oauth_reco_artists))
-        .route("/oauth/reco_tracks", post(oauth_reco_tracks))
-        .route("/oauth/history", post(oauth_history))
         .with_state(state)
         .layer(cors)
         .layer(CompressionLayer::new())